/* DtWidget.js */

Ext.namespace("kw.widget.datatable");

(function() {
    var _view_, _input_, _schema_;
    kw.widget.datatable.VIEW_MODE   = _view_  = 0;
    kw.widget.datatable.INPUT_MODE  = _input_ = 1;
    kw.widget.datatable.SCHEMA_MODE = _schema_= 2;

    kw.widget.datatable.newColCounter = 0;

    kw.widget.datatable.IWidgetSurrogate = function(widget) {
        return {
            widget: widget,

            onSelect:      widget.onSelect ? widget.onSelect.createDelegate(widget) : function() {},
            onDeselect:    widget.onDeselect ? widget.onDeselect.createDelegate(widget) : function() {},
            onPageEdit:    widget.onPageEdit ? widget.onPageEdit.createDelegate(widget) : function() {},
            onPageSave:    widget.onPageSave ? widget.onPageSave.createDelegate(widget) : function() {},
            onPageEditCancel:
                           widget.onPageEditCancel ? widget.onPageEditCancel.createDelegate(widget) : function() {},
            onRemoveWidget:      widget.onRemoveWidget ? widget.onRemoveWidget.createDelegate(widget) : function() {return true;},
            canUpdateSelf: widget.canUpdateSelf ? widget.canUpdateSelf.createDelegate(widget) : function() {return true;},
            onUpdate:      widget.onUpdate ? widget.onUpdate.createDelegate(widget) : function() {},
            getTitle:      widget.getTitle ? widget.getTitle.createDelegate(widget) : function() {return " ";},
            onWidgetMoved :widget.onWidgetMoved ? widget.onWidgetMoved.createDelegate(widget) : function() {}
        };
    };

    ////////////////////////////////////////////
    
    kw.widget.datatable.Field = function(config) {
        this.addEvents({"configupdate": true});
        if (typeof config._fieldId != "undefined")
            this.dataIndex = config._fieldId;
        else
            this.dataIndex = "new_column_".concat(kw.widget.datatable.newColCounter++);
        
        this.mode = _view_;
        this.isKwDatatableField = true;
        if (config.isRequired)
            this.required = true;
        Ext.applyIf(config, {cls: "kw-dtfield"});

        this.subscriptions =[];
        this.subscriptions.push(kw.Events.subscribe(kw.EventNames.DeleteColumnBox, onColumnBoxDelete, this));

        kw.widget.datatable.Field.superclass.constructor.call(this, config);
    };
    Ext.extend(kw.widget.datatable.Field, Ext.form.Field, {
        deleteOnCancelInitialConfig: true,
        
        onDestroy: function() {
            if (this.rowControl)
                this.rowControl.removeField(this);
            Ext.each(this.subscriptions, kw.Events.unsubscribe);
            
            kw.widget.datatable.Field.superclass.onDestroy.apply(this, arguments);
        },

        setMode: function(mode) {
            showRequired.call(this, (mode != _view_) && (this.required || this.isTitleColumn()));
            // KWC-7615
            if( this.isTitleColumn() && mode != _view_)
            {
                kw.DatatableLib.setTitleWidget(this, true);
            }
        },

        onRender: function(ct, pos) {
            kw.widget.datatable.Field.superclass.onRender.apply(this, arguments);
            this.el.addClass("kw-dtfield");
        },

        onUpdate: function(changed) {
            if (this.mode != _view_) {
                showRequired.call(this, this.required);
            }
            this.fireEvent("configupdate", this);
        },

        isRequiredField: function() {
            return this.required;
        },

        isTitleColumn: function() {
            return this.rowControl.getTitleColumn() == this.dataIndex;
        },

        onCancelEdit: function() {
            this.showError(false);
        },
        getFieldBinding : function()
        {
            if (this.portlet && this.portlet.ownerCt && this.portlet.ownerCt.bindings && this.portlet.ownerCt.bindings.length) {
                return this.portlet.ownerCt.bindings[0];
            }
            return null;
        },
        //this method will set this field as the data table title field in schema
        setAsTitle: function(state) {
            this.isTitleField = state;
            //need to set the required option to true for this widget field
            var binding = this.getFieldBinding();
            if (binding)
            {
                var valParam = {
                    isRequired: true                    
                };
                binding.saveConfigParams(valParam);
            }            
            kw.DatatableLib.setTitleWidget(this, state);    
        },

        showError: function(isError, tooltip) {
            kw.DatatableLib.setWidgetError(this, isError, tooltip);
        },

        validate: function() {
            var rowControlMode = this.rowControl.getMode();
            if (rowControlMode != kw.widget.datatable.VIEW_MODE){
                if (!this.originalInputValidate()) {
                    this.showError(true, this.input.getActiveError());                    
                    return false;
                }
            }
            
            if (rowControlMode == kw.widget.datatable.SCHEMA_MODE) {
                return this.schemaModeValidate();
            }
            var isViewMode = (rowControlMode == kw.widget.datatable.VIEW_MODE); //KWC-8712
            var hasValue = true;
            var v = this.getValue();
            if (!v)
            {
                hasValue = false;
            }
            else
            if (Ext.isString(v))
            {
                v = v.trim();
                if (v.length == 0)
                    hasValue = false;
            }
            else
            if (Ext.isArray(v))
            {
                if (v.length == 0 || (v.length == 1 && Ext.isString(v[0]) && v[0].length == 0))
                    hasValue = false;
            }

            if (this.isTitleColumn() && !hasValue && !isViewMode) {
                this.showError(true, kw.Strings.Datatable.nameFieldRequired);
                return false;
            }
            else if (this.required && !hasValue && !isViewMode) {
                this.showError(true, kw.Strings.Datatable.fieldRequired);
                return false;
            }
            else {
                this.showError(false);
                return true;
            }
        },
        
        schemaModeValidate: function() {return true;} // may have overrides
});

    function onColumnBoxDelete(evt, data) {
        if (!this.isTitleField)
            return;

        var matchIt = data.columnBox.id;
        var title = this.title;
        this.findParentBy(function(ct, fld) {
            if (ct.id == matchIt) {
                if (ct instanceof kw.widget.GroupBox)
                    data.reason = String.format(kw.Strings.Datatable.cantDeleteGroupBox, title);
                else
                    data.reason = String.format(kw.Strings.Datatable.cantDeleteColumnBox, title);

                data.canBeDeleted = false;
                return true;
            }
        });
    }

    function addToForm() {
        var rc = this.rowControl = kw.widget.datatable.getRowControlForWidget(this);
        if (rc) {
            rc.addField(this);
            this.portlet.setWidgetTitle(Ext.util.Format.htmlEncode(rc.getFieldTitle(this.dataIndex)));
            this.portlet.addClass("kw-dt-widget");
            this.portlet.header.addClass("kw-dt-widget-title");
        }
        else kw.Util.debugHere("expected row control");
    }

    function showRequired(state) {
        kw.DatatableLib.setWidgetRequired(this, state);
    }

    /////////////////////////////////////////////////////////////////////////////////

    kw.widget.datatable.FieldPlugin = function(config) {};

    kw.widget.datatable.FieldPlugin.prototype = {
        init: function(f) {
            f.fieldAdapter = this;
            f.isFormField = true;
            f.getName = adapterGetName;
            f.isRequiredField = this.isRequiredField.createDelegate(this);
            f.afterRender = f.constructor.prototype.afterRender.createSequence(this.afterRender.createDelegate(this));
            f.isKwDatatableField = true;
            f.deleteOnCancelInitialConfig = true;
            f.cls = f.cls ? (f.cls + " kw-dtfield") : "kw-dtfield";
            if (f.initialConfig.isRequired)
                f.required = true;

            this.field = f;
            if (typeof f.validate == "undefined") {
                f.validate = kw.widget.datatable.Field.prototype.validate;
            }
            if (typeof f.showError == "undefined") {
                f.showError = kw.widget.datatable.Field.prototype.showError;
            }
            if (typeof f.isTitleColumn == "undefined") {
                f.isTitleColumn = kw.widget.datatable.Field.prototype.isTitleColumn;
            }
            f.addEvents({"configupdate": true});
            if (typeof f.initialConfig._fieldId != "undefined")
                f.dataIndex = f.initialConfig._fieldId;
            else
                f.dataIndex = "new_column_".concat(kw.widget.datatable.newColCounter++);

            this.mode = kw.widget.datatable.VIEW_MODE;

            f.setAsTitle = function(state) {
                kw.widget.datatable.Field.prototype.setAsTitle.call(f, state);
            };

            f.getFieldBinding = function() {
                return kw.widget.datatable.Field.prototype.getFieldBinding.call(f);        
            };
            f.subscriptions = f.subscriptions || [];
            f.subscriptions.push(kw.Events.subscribe(kw.EventNames.DeleteColumnBox, onColumnBoxDelete, f));
            if (!f.title && f.portlet)
                f.title = f.portlet.widgetTitle;
        },

        onRender: function() {
            kw.widget.datatable.Field.prototype.onRender.apply(this.field, arguments);
            addToForm.call(this.field);
        },

        setMode: function(mode) {
            this.mode = mode;
            kw.widget.datatable.Field.prototype.setMode.call(this.field, mode);
        },

        onUpdate: function(changedParams) {
            if (typeof changedParams.isRequired != "undefined")
                showRequired.call(this.field, changedParams.isRequired);
        },

        isRequiredField: function() {
            return this.field.required;
        },

        afterRender: function() {
            this.field.initValue();
        }        
    };

    function adapterGetName() {
        return this.title || "";
    }

    ////////////////////////////////////////////

    kw.widget.datatable.SimpleField = function(config) {
        kw.widget.datatable.SimpleField.superclass.constructor.call(this, config);
    };

    Ext.extend(kw.widget.datatable.SimpleField, kw.widget.datatable.Field, {
        beforeDestroy: function() {
            Ext.destroy(this.box);
            kw.widget.datatable.SimpleField.superclass.beforeDestroy.call(this);
        },

        initValue: function() {
            if (this.rowControl.isSchemaPage())
                this.setValue(this.initialConfig._defaultValue);
            else if (this.literalValue)
                this.value = this.literalValue;
            else
                this.value = "";
        },

        onRender: function(ct, pos) {
            if (this.title)
                this.portlet.setWidgetTitle(Ext.util.Format.htmlEncode(this.title));
            
            kw.widget.datatable.SimpleField.superclass.onRender.apply(this, arguments);
            var newEl = Ext.DomHelper.append(this.el.parent(), {tag:"div", cls: "kw-dtfield"});
            Ext.destroy(this.el);
            newEl.id = this.id;
            this.el = Ext.get(newEl);

            this.renderBox({items: this.getInitialRenderItems()});
            addToForm.call(this);
            
            this.ownerCt.on("afterlayout", function() {
                this.box.doLayout();
            }, this);

            this.setMode(this.rowControl.getMode(), true);
        },

        showLiteral: function() {
            this.box.layout.setActiveItem(0);
        },

        showInput: function() {
            this.box.layout.setActiveItem(1);            
        },

        renderBox: function(props) {
            var cfg = {
                autoEl: 'div',
                layout: 'card',
                renderTo: this.el
            };
            Ext.applyIf(cfg, props);
            this.box = new Ext.Container(cfg);
            this.showLiteral();
        },

        getValue: function() {
            if ((this.mode == _input_) || (this.mode == _schema_))
                return this.getInputValue();
            else
                return this.getLiteralValue();
        },

        setValue: function(v) {
            this.value = v;
            if (this.mode == _view_)
                this.setLiteralValue(v);
            else
                this.setInputValue(v);
        },

        setMode: function(mode, bTransferValue) {
            if ((this.mode == _input_) || (this.mode == _schema_)){
                if (mode == _view_) {
                    if (bTransferValue) {
                        this.value = this.getInputValue();
                        this.setLiteralValue(this.value);
                    }
                    this.showLiteral();
                }
            }
            else if (this.mode == _view_) {
                if ((mode == _input_) || (mode == _schema_)) {
                    if (this.box.items.getCount() < 2) {
                        this.input = this.addInputField();
                        if (this.input) {
                            this.input.widget = this;
                            this.originalInputValidate = this.input.validate.createDelegate(this.input);
                            this.input.validate = this.validate.createDelegate(this);
                        }
                    }
                    if (bTransferValue) {
                        var inputValue = this.value;
                        this.value = this.getLiteralValue();
                        this.setInputValue(inputValue);
                    }
                    this.showInput();
                }
            }
            this.mode = mode;
            kw.widget.datatable.SimpleField.superclass.setMode.call(this, mode, bTransferValue);
        },

        disable: function() {
            this.enable(false);
        },

        enable: function(state) {
            if (typeof state == "undefined")
                state = true;
            this.disabled = !state;
            if (this.box.items.getCount() > 1) {
                var f = this.box.items.itemAt(1);
                if (state)
                    f.enable();
                else
                    f.disable();
            }
        },

        addInputField: function() {abstractFn();},
        getInitialRenderItems: function() {abstractFn();},
        getLiteralValue: function() {abstractFn();},
        setLiteralValue: function() {abstractFn();},
        getInputValue: function() {abstractFn();},
        setInputValue: function() {abstractFn();}
    });

    function abstractFn() {
        kw.Util.debugHere("you must implement this method");
    }

    rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/config/RequiredCheckbox.js");

})();

/* DatatableLib.js */

Ext.namespace("kw.DatatableLib");
(function() {

    //register metatypes
    function isDataTableRow(meta) {   // dlm dt
        var t = meta.get("r_object_type");
        return (t && t.indexOf("datatable_row") == 0);
    }


/**
 *  Datatable tree type adapter
 */
kw.DatatableLib.TreeHandler = Ext.extend(kw.widget.NavMapTypeHandler, {
    queryId: "tree_datatable_query",
    overLimitText: kw.Strings.Datatable.TableTreeOverLimit,
    childCountMessage: kw.Strings.nEntries,
    moreChildren: kw.Strings.nMoreEntries,

    /**
     * tree node expander for datatables (call scope the node)
     */
    expand: function (cb, scope){
        var tree = this.getOwnerTree();
        kw.Util.debug("Handler expand: ", this.id);
        var rid=kw.widget.NavMap.getRidFromUniqueId(this.id);
        this.addLoadingCls();
        var queryExecution = new QueryExecution();
        queryExecution.startingIndex = 0;
        queryExecution.maxResultCount = kw.tuning.treeChildMax;
        var filter = new FilterInfo();
        filter.parameters = [
            {name: "datatable_id", value: rid },
            {name: "space_id", value: tree.context.getSpaceId()}];

        filter.execOptions = queryExecution;

        var parentNode = this;
        var callbackProxy = kw.getCallbackClosure(tree, function(data){
                this.addChildrenToNode(parentNode, data, query, filter);
                cb.call(scope, parentNode);
            },
            function _err_(errInfo){
                parentNode.removeLoadingCls();
            });

        var query = {
            datalistId: this.getQueryId(),
            repositories: [tree.context.repository],
            context:kw.Util.getListQueryContainerContext(kw.widget.NavMap.getRidFromUniqueId(this.id))
        };

        var prefs = this._behaviors._getSortingPreferences(tree.context.repository, rid);
        var sort = null;
        if (prefs.DataTableSortField)  {
            sort = [{
                attribute: prefs.DataTableSortField,
                ascending: (prefs.DataTableSortOrder != "DESC")
            }];
        };

        ListService.fetchResults(query, filter, sort, callbackProxy);
    },

    click: function() {
        var ctx = new kw.Context(this.getOwnerTree().context.getUrl());
        ctx.id = this.id;

        if (kw.PagingToolbar.hasSavedGridPage(ctx.getUrl(), ctx.id, ctx.id)) {
            kw.PagingToolbar.clearSavedGridPage();
        }
        return false;
    },

    _getSortingPreferences: function(repo, dtId) {
        var ident = new ObjectIdentity();
        ident.repositoryName = repo;
        ident.valueType = "OBJECT_ID";
        ident.value = dtId;

        var prefSettings = {
            objIdentity: ident
        };
        kw.Util.getPreferences(prefSettings);
        return prefSettings.preferences;
    }
});

(function() {
    kw.DatatableLib.EntryTreeHandler = Ext.extend(kw.widget.NavMapTypeHandler, {
        showChildren:true,
        overLimitText: kw.Strings.Datatable.EntryTreeOverLimit,
        queryId: "entry_attachments",
        forceUpdateOnChildDeletion: true,
        click: function () {   // returns true if the click has been handled
            // this === node
            var tree = this.getOwnerTree();
            if (tree.tab.hasListener("dtentrytreenav"))
                return tree.tab.fireEvent("dtentrytreenav", this.id, _getEntryIndex(this), this.parentNode.id);
            else
                return false;
        },

        getQueryParameters: function() {
            return [
                {name: "row_id", value: this.id},
                {name: "space_id", value: this.getOwnerTree().context.getSpaceProperties().get("r_object_id")}
            ];
        },

        hasChildNodes: function(metadata) {
            return !!metadata.get("_kw_is_row_attachments");
        }
    });

    function _getEntryIndex(node) {
        var p = node.parentNode;
        for (var i=0; i < p.childNodes.length; ++i) {
            if (p.childNodes[i].id == node.id)
                return i;
        }
        return -1;
    }

})();

    /**
     * Register Datatable types
     */
    kw.MetaTypeUtil.register("DATATABLE", 109, "dmc_datatable",
        {canNonGov:false, isPage:true,
         iconCls:"kw-new-datatable", actionCls:"kw-am-DATATABLE",
         childTypes:[110 /*ROW*/, 109/*DATATABLE*/ , kw.MetaType.FOLDER, kw.MetaType.FILE, kw.MetaType.SECTION, kw.MetaType.DISCUSSION, kw.MetaType.BLOG, kw.MetaType.NONE, kw.MetaType.ROOM],
         viewNames: ["home", "attachments"],
         actions:{
                "pastelink":true,
                "resumeedit":false,
                "saveastemplate":true
         },
         handlers:{tree: new kw.DatatableLib.TreeHandler()}
        });

    kw.MetaTypeUtil.register("ROW", 110, {fn: isDataTableRow},
        {canNonGov:false, isPage:true,
         iconCls:"kw-new-datatable-row  kw-action-icon", actionCls:"kw-am-ROW",
         childTypes:[kw.MetaType.FILE,kw.MetaType.FOLDER, kw.MetaType.DATATABLE, kw.MetaType.SECTION, kw.MetaType.DISCUSSION, kw.MetaType.BLOG, kw.MetaType.NONE, kw.MetaType.ROOM],
         parentType:kw.MetaType.DATATABLE,
         viewNames: ["parenthome"],
         actions:{
                "pastelink":true,
                "rename": false,
                "move": false,
                "cut": false,
                "resumeedit":false
         },
         handlers:{tree: new kw.DatatableLib.EntryTreeHandler()}
        });
    kw.MetaTypeUtil.register("SCHEMA", 111, "dmc_datatable_schema",
        {isPage:true,
         iconCls:"",      // dlm todo need icon class
         childTypes:[],
         viewNames: null,
         actions:{
                 "cut": false
         }});
    kw.MetaTypeUtil.register("DTTEMPLATE", 204, {r_object_type: "dmc_kw_template", a_target_application_type: "dmc_datatable"},
        {iconCls:"kw-new-datatable",
         childTypes:[],
         viewNames: null
        });

    // add datatable as childtype of folder and space
    var typeinfo;
    typeinfo=kw.MetaTypeUtil.getTypeInfo(kw.MetaType.SPACE);
    typeinfo.childTypes.push(kw.MetaType.DATATABLE);
    typeinfo=kw.MetaTypeUtil.getTypeInfo(kw.MetaType.FOLDER);
    typeinfo.childTypes.push(kw.MetaType.DATATABLE);
    typeinfo=kw.MetaTypeUtil.getTypeInfo(kw.MetaType.CABINET);
    typeinfo.childTypes.push(kw.MetaType.DATATABLE);
    typeinfo=kw.MetaTypeUtil.getTypeInfo(kw.MetaType.ROOM);
    typeinfo.childTypes.push(kw.MetaType.DATATABLE);

// add opStatusSet error translator
// If all messages are the same, rollup to a single message.
kw.ErrorTranslator.add(function(data){
    if (data.messageId!="KW_E_COPY_MULTI_ITEM" && data.messageId!="KW_E_DATATABLE_E_LOCKED") return false;
    var ops=data.operationStatusSet;
    for (var i=0, len=ops.length; i<len;i++){
        if (ops[i].messageId!="KW_E_DATATABLE_E_LOCKED") return false;
    }
    return (len==0) ? false : (len==1) ? kw.Strings.Datatable.copyErrorLocked: kw.Strings.Datatable.copyErrorLocked_plural;
});

    /**
     * add to kw.Context()
     * NOTE: This perhaps could have a better place...  This code needs to be loaded at startup (which is is now)
     */
    Ext.applyIf(kw.Context.prototype, {
        /**
         * Get datatable properties; returns context.getContextProperties() if context is the datatable
         *   If ROW,
         */
        getDataTableProperties:function(){
            if (this._dtproperties)
                return this._dtproperties;

            var meta=this.getContextProperties();
            var metaType = meta.getMetaType();
            if (metaType == kw.MetaType.DATATABLE) {
                return meta;
            }

            var objectIdentity = this.getObjectIdentity();
            if (metaType == kw.MetaType.ROW) {
                var i_folder_id = meta.get("i_folder_id");
                if (i_folder_id.length>1) kw.Util.debugHere("item is linked; bad assumption!");
                objectIdentity.value = meta.get("i_folder_id")[0].id;
            }
            else if (metaType == kw.MetaType.SCHEMA) {
                kw.Util.debugHere("is schema");
                objectIdentity.value = kw.Util.getQueryStringParam("datatableid", this.queryString);
            }
            else {
                throw new Error("Not a datatable related context!");
            }

            var cache = null;
            if (!this._dtproperties){
                if (cache = this.getCache())
                    this._dtproperties = cache.getById(objectIdentity.value);
            }

            if (!this._dtproperties) {
                var propertyConfig= {};
                Ext.applyIf(propertyConfig, {objectIdentity:objectIdentity, profile:this.getContextPropertiesProfile()});
                this._dtproperties = new kw.Properties(propertyConfig);
            }
            if (cache && this._dtproperties){
                cache.add(this._dtproperties, objectIdentity.value);
            }
            this._dtproperties.load(true);
            return this._dtproperties;
        },
        /**
         * Get fields for a datatable
         * Method is added to context; result is added to context metadata.
         */
        getFields: function(){
                var meta = this.getContextProperties();
                var fields = meta.get("fieldsInfo");
                if (fields) return fields;

                var datatableId = new ObjectIdentity();
                datatableId.repositoryName = this.repository;
                datatableId.valueType = "OBJECT_ID";

                var metaType = meta.getMetaType();
                if (metaType == kw.MetaType.DATATABLE) {
                    datatableId.value = meta.get("r_object_id");
                }
                else if (metaType == kw.MetaType.ROW) {
                    datatableId.value = meta.get("i_folder_id")[0].id;
                }
                else if (metaType == kw.MetaType.SCHEMA) {
                    datatableId.value = kw.Util.getQueryStringParam("datatableid", this.queryString);
                }
                else {
                    throw new Error("Not a datatable related context!");
                }

                var config = {};
                config.serviceMethod = ListService.fetchResults;
                var dtq = {};
                dtq.repositories = [this.repository];
                dtq.tableIdentity = new ObjectIdentity();
                dtq.tableIdentity.repositoryName = this.repository;
                dtq.tableIdentity.value = datatableId.value;
                dtq.tableIdentity.valueType = "OBJECT_ID";

                var filter = new FilterInfo();
                filter.parameters = [{name: "table_id", value: datatableId.value}];
                config.storeLoadParams = {serviceMethodParams: { dtQuery: dtq, filter:filter, sorting:null}, datalistId: datatableId.value};
                meta._items["fieldsInfo"]=kw.data.getQueryMetadata(config).columnDefinition;
                return meta._items["fieldsInfo"];
            }
    });



    kw.DatatableLib.EditRow = function(actionArgs, rowControl) {
        var progress = {};
        kw.Progress.ShowProgress(progress);

        function onCheckout(data)
        {
            bCheckOutSuccessful = (kw.ActionLib.handleStatusReturn(data) === true);
            if (bCheckOutSuccessful) {
                if(rowControl == undefined) {
                    var rc = kw.widget.datatable.getRowControlForWidget(actionArgs.component);
                    rc.editRow();
                }  else {
                    // We pass the rowControl from grid since it has a handler (see kw.Action.Datatable.EditEntryFromGrid)
                    rowControl.editRow();
                }
                kw.Progress.EndProgress(progress);
            }
        };

        var objIdentity = new ObjectIdentity();
        objIdentity.value = actionArgs.context.id;
        objIdentity.valueType = "OBJECT_ID";
        objIdentity.repositoryName = actionArgs.context.repository;
        var idset = {identities:[objIdentity]};

        var _error=function(excName,excObj){
            kw.Util.debug("ERROR ContentService.checkout: "+ excObj.message);
            kw.Progress.EndProgress(progress);
        };
        var callbacks = kw.getCallbackClosure(this, onCheckout, _error);
        callbacks.async=false;
        ContentService.checkout(idset, null, callbacks);
    };

    kw.DatatableLib.navigateEditMode=function(context, callback, scope){
        var activeTab = kw.RendEng.getTabManager().getActiveTab();
        var navSubscription = null;
        navSubscription = kw.Events.subscribe(kw.EventNames.Navigated, function(name, navactionArgs) {
                var tabKey = navactionArgs.context.space;
                activeTab = kw.RendEng.getTabManager().lookupTab(tabKey);
                if (activeTab)
                    activeTab.on(kw.EventNames.DeferredBinding, getEditRow, this, {single: true});
            }, this);
        function getEditRow(){
            var myTab = kw.RendEng.getTabManager().getActiveTab();
            if (myTab)
                myTab.un(kw.EventNames.DeferredBinding, getEditRow, this);
            if (navSubscription)
                kw.Events.unsubscribe(navSubscription);

            var rc = kw.widget.datatable.getRowControl(myTab.el.dom);
            rc.on(kw.EventNames.EditPage, callback, scope, {single: true});

            var newActionArgs = {context: context};
            kw.DatatableLib.EditRow(newActionArgs, rc);
        }
        kw.RendEng.navigate(context);
    };

    kw.DatatableLib.EditSchema = function (actionArgs)
    {
        var progress = {};
        var schemaId, ctx;
        var metadata = actionArgs.context.getContextProperties();
        var target = actionArgs.context.id;

        if (kw.Util.hasSelection(actionArgs)) {
            metadata = actionArgs.selection.items[0].metadata;
            target = metadata.get("r_object_id");
        }
        if (!target)
            return;

        // Must lock the schema object before navigate to it for edit.
        function onCheckout(data)
        {
            var bCheckOutSuccessful = (kw.ActionLib.handleStatusReturn(data) === true);
            if (bCheckOutSuccessful) {
                var evtactionArgs = new kw.ActionArgs({
                    context: actionArgs.context.cloneContext(),
                    metadata: new kw.MetaData({'r_object_id': target,
                                               'r_lock_owner': kw.getCurrentMemberUserName()})});
                kw.Events.publish(kw.EventNames.PageLocked, evtactionArgs);

                var ctx = actionArgs.context.getContext(metadata);
                ctx.id = schemaId;
                ctx.view = "content";
                ctx.queryString = "?foredit=true&datatableid=" + target;
                kw.ActionLib.navigateCallback(ctx, function(){
                    kw.Progress.EndProgress(progress);
                },this);
            }
        }

        function schemaIdError(e) {
            kw.Progress.EndProgress(progress);
            throw new Error("can't get schema id for data table");
        }

        function schemaCheckout(){

            var schemaObjIdentity = new ObjectIdentity();
            schemaObjIdentity.value = schemaId;
            schemaObjIdentity.valueType = "OBJECT_ID";
            schemaObjIdentity.repositoryName = actionArgs.context.repository;
            var idset = {identities:[schemaObjIdentity]};

            var _error=function(excName,excObj){
                kw.Progress.EndProgress(progress);
                kw.Util.debug("ERROR ContentService.checkout: "+ excObj.message);
            };
            var callbacks = kw.getCallbackClosure(this, onCheckout, _error);
            ContentService.checkout(idset, null, callbacks);
        }

        function gotSchemaId(result) {
            schemaId = result;
            ctx = actionArgs.context.getContext(metadata);
            ctx.id = schemaId;
            ctx.view = "content";
            ctx.queryString = "?foredit=true&datatableid=" + target;

            var myTab = kw.RendEng.getTabManager().getActiveTab();

            if (kw.widget.datatable.getRowControlForWidget){
                var rc = kw.widget.datatable.getRowControl(myTab.el.dom);
                if (rc && (rc.state._isNewEntry || (rc.state._mode == kw.widget.datatable.INPUT_MODE))){
                    rc.addEvents("navhookbeforeschemaedit");
                    rc.on("navhookbeforeschemaedit", schemaCheckout, this);
                    rc.navHook(ctx, true);
                }else
                    schemaCheckout();
            }else
                schemaCheckout();

        }
        kw.Progress.ShowProgress(progress);
        kw.DatatableLib.getSchemaId(actionArgs, target, gotSchemaId, schemaIdError, this);
    };

    kw.DatatableLib.setWidgetRequired = function(widget, state) {
        var headerText = widget.portlet.header.child(".x-panel-header-text");
        if (headerText) {
            if (state)
                headerText.addClass("kwrequired");
            else
                headerText.removeClass("kwrequired");
        }
        else kw.Util.debugHere("expected element");
    };

    kw.DatatableLib.setWidgetError = function(widget, state, tooltip) {
        var iconCls = "kw-dtfield-error-icon";
        var errorIconSpan = widget.portlet.header.child("."+ iconCls);
        if (!errorIconSpan && state) {
            errorIconSpan = widget.portlet.header.insertFirst({tag: "span", cls: iconCls, html: "&nbsp;"});
            errorIconSpan.setVisibilityMode(Ext.Element.DISPLAY);
            var qt = new Ext.QuickTip({target: errorIconSpan, interceptTitles: true});
            widget.on("destroy", function() {Ext.destroy(qt);});
        }
        if (state) {
            errorIconSpan.dom.setAttribute("title", tooltip);
            errorIconSpan.show();
            widget.portlet.header.addClass("kw-dte-error");
        }
        else if (errorIconSpan) {
            errorIconSpan.hide();
            widget.portlet.header.removeClass("kw-dte-error");
        }
    };

    kw.DatatableLib.setTitleWidget = function(widget, state)
    {
        if (!widget.rendered) {
            widget.on("afterrender", function() {
                kw.DatatableLib.setTitleWidget(this, state);
            }, widget, {single: true});
            return;
        }
        var tools = widget.ownerCt.tools;
        tools.close.disabled = state;
        var _dom = widget.portlet.ownerCt.getLayoutTarget().dom;
        if (state) {
            if ((typeof(widget._titleHelper) == "undefined") || (widget._titleHelper == null))
            {
                widget._titleHelper = Ext.DomHelper.append(_dom, {tag: 'span', cls: 'kwhelp', html: kw.Strings.Datatable.TitleWidgetHelpText});
            }
        }
        else {
            _dom.removeChild(widget._titleHelper);
            widget._titleHelper = null;
        }
        kw.DatatableLib.setWidgetRequired(widget, true);    //the previous title widget needs to have 'required' checked
    };

    kw.DatatableLib.CreateRow = function (actionArgs)
    {
        var schemaId;
        var target = actionArgs.context.id;
        var meta = actionArgs.context.getContextProperties();

        if (kw.Util.hasSelection(actionArgs)) {
            meta = actionArgs.selection.items[0].metadata;
            target = meta.get("r_object_id");
        }

        if (meta && meta.getMetaType() == kw.MetaType.ROW) {
            target = meta.get("i_folder_id")[0].id;       // get the data table where this row belongs.
        }

        if (!target)
            return;

        function onEditEntry() {
            var myTab = kw.RendEng.getTabManager().getActiveTab();
            var rc = kw.widget.datatable.getRowControl(myTab.el.dom);
            rc.pageControl.box.doLayout(false, true);
            rc.editRow();
        }

        var activeTab = kw.RendEng.getTabManager().getActiveTab();
        activeTab.on(kw.EventNames.DeferredBinding, onEditEntry, this, {single: true});
        var ctx = actionArgs.context.cloneContext();
        ctx.id = target;
        ctx.view = "content";
        ctx.queryString = "?mode=entry";
        kw.RendEng.navigate(ctx);
    };

// can use ContentService.cancelCheckout(idset, callbacks);   w/ datatable id now
//    kw.DatatableLib.UnlockSchema = function (actionArgs)
//    {
//
//        // TODO: We need to show up 2 differnt confirmation dialogs before trying to unlock/Cancel Editing the Schema - Sarada
//        var schemaId;
//        var target = actionArgs.context.id;
//        if (kw.Util.hasSelection(actionArgs)) {
//            target = actionArgs.selection.items[0].metadata.get("r_object_id");
//        }
//        if (!target)
//            return;
//
//        function schemaIdError(e) {
//            throw new Error("can't get schema id for data table");
//        }
//
//        function gotSchemaId(result) {
//            schemaId = result;
//            var schemaObjIdentity = new ObjectIdentity();
//            schemaObjIdentity.value = schemaId;
//            schemaObjIdentity.valueType = "OBJECT_ID";
//            schemaObjIdentity.repositoryName = actionArgs.context.repository;
//            var idset = {identities:[schemaObjIdentity]};
//
//            var onCancelCheckout = function(data)
//            {
//                var evtactionArgs = new kw.ActionArgs({
//                    context: actionArgs.context,
//                    metadata: {r_object_id: target}
//                });
//                kw.Events.publish(kw.EventNames.ItemModified, evtactionArgs);
//            };
//
//            var _error = function(excName, excObj){
//                kw.Util.debug("ERROR ContentService.checkout: "+ excObj.message);
//            };
//
//            var callbacks = kw.getCallbackClosure(this, onCancelCheckout, _error);
//            ContentService.cancelCheckout(idset, callbacks);
//        }
//
//        kw.DatatableLib.getSchemaId(actionArgs, target, gotSchemaId, schemaIdError, this);
//    };

    kw.DatatableLib.validateMemberScope = function(newTitle) {
        // if editing the schema, and looking for specific members
        if (this.getValue() != this.allSpaceMembersString)
        {
            var itemList = this.ownerCt.items.items;
            if ((this.memberListIdx == undefined) || (this.isRequiredIdx == undefined))
            {
                for (var idx=0; idx < itemList.length; idx++)
                {
                    if (itemList[idx].name == 'memberList')
                        this.memberListIdx = idx;
                    if (itemList[idx].name == 'isRequired')
                        this.isRequiredIdx = idx;
                }
            }

            // and column is required
            if (itemList[this.isRequiredIdx].getValue())
            {
                // and no members are selected...
                if (itemList[this.memberListIdx].members.length == 0)
                    return kw.Strings.Datatable.mustSelectOneMember;
            }
        }
        return true;
    }

    var MAX_LENGTH_OF_DT_FIELD_TITLE = 64;

    /**
     * validator -- don't allow value to be reduced from initial value
     * @param v
     */
    kw.DatatableLib.validateNoReduction = function(v) {
        var cmp=Ext.getCmp(this.el.findParent(".kwdialog").id);
        var widget=cmp.actionArgs.component.component.widget;
        var bind=widget.getFieldBinding();
        if (!bind.saved) return true;
        var origv = this.initialConfig.value;
        var loadedConfig=widget.loadedConfig;   // config at the time of widget creation
        if (loadedConfig.characters)
            origv =loadedConfig.characters; 
        return (v>=origv) ? true: kw.Strings.Datatable.NoReduction;
    };

    kw.DatatableLib.validateUniqueTitle = function(newTitle) {
        newTitle = newTitle.trim();

        //kwc-8504 - check for max length execeeded
        if (newTitle && (newTitle.length > MAX_LENGTH_OF_DT_FIELD_TITLE)) {
            return kw.Strings.Datatable.titleTooLong;
        }
        newTitle = Ext.util.Format.htmlEncode(newTitle);
        
        if (!this._savedPortletId) {
            var dlg = this.findParentBy(function(p) {return p.el.hasClass("kwdialog");});
            this._savedPortletId = dlg.actionArgs.component.id;
        }
        var f = Ext.getCmp(this._savedPortletId);
        if (!f)
            return true;

        if (f.title == newTitle)
            return true;

        if (!this._savedRowControlId) {
            this._savedRowControlId = kw.widget.datatable.getRowControlForWidget(f).id;
        }
        var rc = Ext.getCmp(this._savedRowControlId);

        if (rc && rc.form.findFieldByTitle(newTitle)) {
            return kw.Strings.Datatable.fieldNameInUse;
        }
        return true;
    };

    kw.DatatableLib.ResetToContainerPermissions = function(actionArgs)
    {
        kw.ScriptLoader.requireStrings("Datatable");
        kw.ScriptLoader.requireStrings("Permissions");
        var progress = {};

        var _complete = function(data) {
            var oid = actionArgs.context.getObjectIdentity();
            kw.Events.publish(kw.EventNames.AclChanged, oid);
            kw.Progress.EndProgress(progress);
            if (actionArgs.returnCallback)
            {
                actionArgs.returnCallback(data, "updatePermissions");
            }
        }

        var resetPermissions = function(btn) {
            if (!kw.ActionLib.affirmed(btn))
            {
                return;
            }

            kw.Progress.ShowProgress(progress);

            var pp = new PermissionsProfile();
            pp.resetToContainerPermissions = true;
            var objectIdentity = actionArgs.context.getObjectIdentity();
            var callbacks = kw.getCallbackClosure(this, _complete);
            try
            {
                PermissionService.updatePermissions(objectIdentity, null, pp, callbacks);
            }
            catch(ex)
            {
                kw.Progress.EndProgress(progress);
                throw ex;
            }
        }

        var metadata = actionArgs.context.getContextProperties();
        var objectName = metadata.get("object_name");
        var aclContainerName = actionArgs.aclContainerName;

        kw.MessageBox.show({
            title:  kw.Strings.Permissions.resetToParentACLPromptTitle,
            msg:  String.format(kw.Strings.Permissions.resetToParentACLPromptText, objectName, aclContainerName),
            buttons:  Ext.MessageBox.OKCANCEL,
            icon:   Ext.MessageBox.WARNING,
            fn: resetPermissions
        }, actionArgs);
    }

    kw.DatatableLib.globalDatatableCreate = function(actionArgs, createMetaType){
        kw.ScriptLoader.require("js/kw/Dialog/BasicSourcePicker.js");

        var selectionMade = function(itemName, itemId, imageUrl, itemPath, isFolder, spaceUrlName)
        {
            var createArgs = kw.Util.clone(actionArgs);
            createArgs.context = new kw.Context({repository: actionArgs.context.repository,
                                                 _spaceId: itemId,
                                                 space: spaceUrlName});

            createArgs.space_object_name=itemName;  // pass in space object name to avoid getting space properties if not present on context
            var selectedLocId = new ObjectIdentity();
            selectedLocId.value = itemId;
            selectedLocId.valueType = "OBJECT_ID";
            selectedLocId.repositoryName = actionArgs.context.repository;
            createArgs.locationId = selectedLocId;

            if (createMetaType == kw.MetaType.DATATABLE) {
                kw.ActionManager.showDialog(kw.Dialog.DatatableCreate, createArgs);
            }
        };

        //helpid assignment
        if (createMetaType == kw.MetaType.DATATABLE) {
            actionArgs.helpid = "cents_add_table";
        }

        // show the source picker to choose a space
        var newActionArgs = kw.Util.clone(actionArgs);
        newActionArgs.selectionCallback = selectionMade.createDelegate(this);
        newActionArgs.context = kw.getContext();
        var dialogTitle = kw.Util.getTypeSpecificString(kw.Strings.ChooseSource.selectSpace_Title._tbl, createMetaType);

        var locPicker = new kw.Dialog.GlobalNewLocationPicker({
            actionArgs: newActionArgs,
            autoProgress: false,
            allowedType: "dmc_kw_space_folder",
            titleSelected: dialogTitle,
            defaultSelection: kw.getContext().getSpaceId()
        });

        if (locPicker.getInitialDataStore) {
            var progress = {};
            function onInitDataStoreLoad (store, results, params){
                kw.Progress.EndProgress(progress);
                if (store.data.length == 1) {
                    var metaData = store.getAt(0); // only one
                    selectionMade(metaData.get("object_name"), metaData.get("r_object_id"),
                                  metaData.get("_kw_icon").smIconUrl, metaData.get("_kw_primary_location"), false, metaData.get("_kw_space_urlname"));
                }
                else {
                    locPicker.show();
                }
            }
            kw.Progress.ShowProgress(progress);
            var dataStore = locPicker.getInitialDataStore(this, onInitDataStoreLoad);
        }
        else {
            locPicker.show();
        }

    };

    /* get schema id (using cache or context metadata if possible); success is called w/ schemaId as simple arg.
    */
    kw.DatatableLib.getSchemaId = function (actionArgs, tid, success, failure, scope)
    {
        var schemaId;
        if (schemaId=kw.data.DtMetadataCache.getProperty(tid, "schema_id")){
            success.call(scope, schemaId);
            return;
        }else if(tid==actionArgs.context.id
                && (schemaId=actionArgs.context.getContextProperties().get("schema_id", true))){
            kw.data.DtMetadataCache.updateCache(tid, {schema_id: schemaId});
            success.call(scope, schemaId);
            return;
        }
        function localSuccess(result){
            schemaId = result.properties.schema_id.id;
            kw.data.DtMetadataCache.updateCache(tid, {
                schema_id: schemaId,
                object_name: result.properties.object_name
            });
            success.call(scope, schemaId);
        }

        var objectIdentity = new ObjectIdentity();
        objectIdentity.repositoryName = actionArgs.context.repository;
        objectIdentity.value = tid;
        objectIdentity.valueType = 'OBJECT_ID';

        var propertyProfile = new PropertyProfile();
        propertyProfile.includeProperties = ["schema_id"];
        ContentService.getObject(objectIdentity,
                                     propertyProfile,
                                     kw.getCallbackClosure(scope, localSuccess, failure));
    };

    /** kwc-8405   kwc-8549
     * Get markup for entry title name (name is link to the entry).
     * @param context
     * @param record
     * @param name
     * @param ops
     */
    kw.DatatableLib.getTitleColumnEntryNameMarkup = function(context, record, value /* optional*/, ops /*optional*/) {
        if(!value) return "";    //KWC-8730
        ops = ops || {};
        var link = kw.Util.getNameLink(context, record);
        var linkcls = "kw-dtentrylist-title-link";

        var title = value;
        title = Ext.util.Format.stripTags(title);

        // KWC-21453:  encode quotes in tooltip markup to prevent syntax errors when substituting into template
        title = title.replace(/'/g, '&#39;');
        title = title.replace(/"/g, '&quot;');

        var template = "<a title='{0}' class='{1}' onclick='kw.ActionManager.dispatchOnEntryTitleClick(event,\"kw.Action.ViewPage\", \"{2}\")'>{3}</a>"
        return String.format(template, title, linkcls, link.url, value);
    };
/** -------------------------------------------------------------------------------
 *   Datatable store and property Cache
 *
 *
 */
Ext.namespace("kw.data");
var MC = kw.data._dtMetadataCache = {};
kw.data.DtMetadataCache = (function(){
    var impl = {
        get: function (key){
            return MC[key];
        },
        getProperty: function (key, name){
            var cache= MC[key];
            if (cache){
                return cache[name];
            }
            return undefined;
        },
        updateCache: function(key, items){
            var cache= MC[key];
            if (!cache)
                cache= MC[key] = items;
            else{
                Ext.apply(cache, items);
            }
            return cache;
        }
    };

    function onItemModified(evtName, actionArgs) {
        var itemId = actionArgs.metadata.get("r_object_id");
        if (itemId && this.get(itemId)) {
            var objName = actionArgs.metadata.get("object_name");
            if (objName) {
                this.updateCache(itemId, {object_name: objName});
            }
        }
    }

    kw.Events.subscribe(kw.EventNames.ItemModified, onItemModified, impl);

    return impl;
})();

/*  ----------------------------------------------------------------------------------------------------------*/



})();   //END kw.DatatableLib
Ext.namespace("kw.debug");
kw.debug.DatatableLib = function() {eval("debugger")};

// SchemaModePlaceholder.js

/////////////////////////////////////////////////////////////////////////
// SchemaModePlaceholder -- appears only on the Fields and Settings page    

kw.widget.SchemaModePlaceholder = function(config) {
    rcmp.intf.attachInterfaces(this, kw.widget.SchemaModePlaceholder);
    var thisConfig = {cls: "kw-dtfield"};

    Ext.applyIf(thisConfig, config);
    if (thisConfig.name)
        this.name = thisConfig.name;
    else
        this.name = "";

    kw.widget.SchemaModePlaceholder.superclass.constructor.call(this, thisConfig);
};

Ext.extend(kw.widget.SchemaModePlaceholder, Ext.Panel, {
    onDestroy : function(){
        Ext.each(this.subscriptions, kw.Events.unsubscribe);
        kw.widget.SchemaModePlaceholder.superclass.onDestroy.call(this);
    },

    onRender : function(container, position) {
        kw.widget.establishContext(this, this.initialConfig, container);

        kw.widget.SchemaModePlaceholder.superclass.onRender.call(this, container, position);
        if (this.portlet) {
            if (this.name)
                this.portlet.setWidgetTitle(this.name);
            else
                this.portlet.setWidgetTitle(true); // show header even if empty
            this.portlet.userConfigurable = false;
            this.portlet.showHeader(true);
            if (this.initialConfig.onDeleteMessage)
                this.portlet.on("deletewidget", this.onDeleteWidget, this);
        }
    },

    onPageEdit: function(bCanChangeLayout)  { },
    onPageSave: function(bCanChangeLayout) {},
    onPageEditCancel: function(bCanChangeLayout) {},
    onSelect: function(pageMode, evt) {},
    onDeselect: function(pageMode) {},
    onRemoveWidget: function() { return true; },
    onWidgetMoved: function() {},
    getTitle: function() {
        return kw.Util.retainWhiteSpaces(Ext.util.Format.htmlEncode(this.name));
    },
    canUpdateSelf : function(configParams) {
        return true;
    },

    onUpdate : function(changedConfigParams)  {
        if (typeof changedConfigParams.name != "undefined")
        {
            this.name = changedConfigParams.name;
            if (this.portlet) {
                if (this.name)
                    this.portlet.setWidgetTitle(this.getTitle());
                else
                    this.portlet.setWidgetTitle(true);
                this.portlet.showHeader(true);
            }
        }
    },

    onDeleteWidget: function(props) {
        props.message = this.initialConfig.onDeleteMessage;
    }
});
/* DatatableActions.js */
/**
 *  CenterStage Datatable and Entry Actions!
 */

Ext.namespace("kw.Action.Datatable");
kw.ScriptLoader.require("js/kw/Dialog/SaveAsTemplate.js");
kw.ScriptLoader.require("js/kw/Dialog/TemplateSettings.js");
kw.ScriptLoader.require("js/kw/widget/CommunityPageNav.js");
kw.ScriptLoader.require("js/kw/Dialog/BasicSourcePicker.js");
kw.ScriptLoader.requireStrings("Datatable");
kw.ScriptLoader.requireStrings("DatatableSaveAsTemplate");

rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/DatatableLib.js");
rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/DatatableCreate.js");
rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/DatatableImport.js");
rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/DatatableExport.js");

rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib", "js/entryPreviewBubbleListContainer.js");

// add db types to core actions
kw.Action.ContentImport.initialConfig.selectionTypes.push(kw.MetaType.DATATABLE);
kw.Action.ContentImport.initialConfig.selectionTypes.push(kw.MetaType.ROW);
kw.Action.SaveAsTemplate.initialConfig.selectionTypes.push(kw.MetaType.DATATABLE);
kw.Action.ItemPaste.initialConfig.selectionTypes.push(kw.MetaType.DATATABLE);
kw.Action.ItemPaste.initialConfig.selectionTypes.push(kw.MetaType.ROW);
kw.Action.NewItemsSubMenu.initialConfig.selectionTypes.push(kw.MetaType.ROW);

/* Save As Template */
kw.Dialog.SaveAsTemplate.templateTypes[kw.MetaType.DATATABLE]=
                                        {title: kw.Strings.Dialog.DatatableSaveAsTemplate.datatableTitle,
                                        uniqueNameScope: kw.Strings.Dialog.DatatableSaveAsTemplate.uniqueNameInSpace,
                                        datalistId: "datatable_templates",
                                        includeIcon: false,  // not in V1
                                        includeTemplateAccessScope: true,                                        
                                        templateAlreadyExistMessage: kw.Strings.Dialog.DatatableSaveAsTemplate.datatableTemplate_exist,
                                        createMethodName: "createTemplate"};

/* Template Settings */
Ext.applyIf(kw.TemplateSettings.templateTypes, {dmc_datatable : {datalistId: "datatable_templates",
                                                includeIcon: false,
                                                includeTemplateAccessScope: true,                                                
                                                updateMethodName: "updateTemplate"}});

/* Community Page */
Ext.apply(kw.widget.CommunityPageNav.recentActivityConfigPro, {additionalItems: [(new kw.widget.CommunityPageNavButton({
                                            allowDrag: false,
                                            allowDrop: false,
                                            cls: "kw-communityNavButton",
                                            text: kw.Strings.Datatable.RecentActivity.recentEntries,
                                            iconCls: "kw-datatableEntryRecent16",
                                            qtip:   kw.Strings.Datatable.RecentActivity.recentEntriesTip,
                                            navid: "page", pgview: "community_rEntries" }))]});

/* Choose a Source Dialog */
Ext.applyIf(kw.Dialog.BasicSourcePicker.allowedTypes, {dmc_kw_space_folder: { defaultScope: kw.SearchScopeEnum.ALL_MY_SPACES_EDITABLES,
                                                    searchScopes: [kw.SearchScopeEnum.FAVORITE_SPACES_EDITABLES,
                                                                    kw.SearchScopeEnum.ALL_MY_SPACES_EDITABLES,
                                                                    kw.SearchScopeEnum.RECENT_ITEMS_EDITABLES
                                                    ],
                                             params: [{name: "show_datatable_locations", value: ""}]}});

/* Preview Bubble Datatable and Entry Type defintions */


kw.bubble.previewBubble.push(kw.MetaType.DATATABLE);
kw.bubble.previewBubble.push(kw.MetaType.ROW); 
kw.bubble.previewBubble.push(kw.MetaType.DTTEMPLATE);

kw.bubble.metaTypes[kw.MetaType.DATATABLE]=
        {
            queryId: 'datatable_query',
            filter_parameterName: "datatable_id",
            metadataList: [
                kw.bubble.sysinfoDisplayType.CREATED,
                kw.bubble.sysinfoDisplayType.UPDATED,
                kw.bubble.sysinfoDisplayType.CONTAINS,
                kw.bubble.sysinfoDisplayType.COMMENTS,
                kw.bubble.sysinfoDisplayType.TAG
                ],
            stringsInBubble: {
                listBoxTitleLC: kw.Strings.DatatablePreviewPanel.StringInBubble._entriesLC,
                listBoxChildrenCountUC: kw.Strings.DatatablePreviewPanel.StringInBubble._entriesUC,
                listBoxTitleUC: kw.Strings.DatatablePreviewPanel.StringInBubble._entriesUC
            },
            bubbleLayout :[{xtype: 'kwpreviewbubbleheader',
                                region: 'north',
                                height: 25},
                            {xtype: 'kwpreviewbubblelistcontainer',
                                region: 'center',
                                bodyStyle: 'background-color:#f5fcf2;',
                                margins: '0 0 15 0'},
                            {xtype: 'kwpreviewbubblefooter',
                                region: 'south',
                                toolbarName : 'kw.bubble.previewbubble.footertoolbar.DATATABLE'}
                        ]
        };
kw.bubble.metaTypes[kw.MetaType.ROW]=
        {
            queryId: 'datatable_entry_query',
            filter_parameterName: "entry_id",
            metadataList: [
                kw.bubble.sysinfoDisplayType.CREATED,
                kw.bubble.sysinfoDisplayType.UPDATED,
                kw.bubble.sysinfoDisplayType.LOCATED,
                kw.bubble.sysinfoDisplayType.COMMENTS,
                kw.bubble.sysinfoDisplayType.TAG
                ],
            stringsInBubble: {},
            bubbleLayout :[{xtype: 'kwpreviewbubbleheader',
                                region: 'north'},
                            {xtype: 'kwentrypreviewbubblelistcontainer',
                                region: 'center',
                                bodyStyle: 'background-color:#f5fcf2;',
                                margins: '0 0 15 0'},
                            {xtype: 'kwpreviewbubblefooter',
                                region: 'south',
                                toolbarName : 'kw.bubble.previewbubble.footertoolbar.ROW'}
                        ]
        };

kw.bubble.metaTypes[kw.MetaType.DTTEMPLATE] = {                
                metadataList: [
                    kw.bubble.sysinfoDisplayType.DESCRIPTION,
                    kw.bubble.sysinfoDisplayType.TEMPLATECATEGORY,
                    kw.bubble.sysinfoDisplayType.CREATED,
                    kw.bubble.sysinfoDisplayType.UPDATED
                    ],
                stringsInBubble: {},
                bubbleLayout :[{xtype: 'kwpreviewbubbleheader',
                                region: 'north'},
                            {xtype: 'kwpreviewbubbletemplateinfo',
                                region: 'center',
                                bodyStyle: 'background-color:#f5fcf2;',
                                margins: '0 0 15 0'},
                            {xtype: 'kwpreviewbubblefooter',
                                region: 'south',
                                toolbarName : 'kw.bubble.previewbubble.footertoolbar.DTTEMPLATE'}
                        ]
        };

kw.bubble._metatype_bubbletype_table[kw.MetaType.DATATABLE] =  kw.bubble.bubbleType.LISTCONTAINER;
kw.bubble._metatype_bubbletype_table[kw.MetaType.ROW] = kw.bubble.bubbleType.TEXTCONTAINER;
kw.bubble._metatype_bubbletype_table[kw.MetaType.DTTEMPLATE] = kw.bubble.bubbleType.NOCONTAINER;

/* End of Preview Bubble code*/

// this is for the editing toolbar (don't use in context menu)
kw.Action.Datatable.buttonTemplate = kw.Action.Page.buttonTemplate;

kw.Action.Datatable.Export = new kw.Action({
    aid: "kw.Action.Datatable.Export",
    iconCls:"kw-dt-export kw-action-icon",
    text: kw.Strings.Action.DatatableExport._text,
    contextTypes: [kw.MetaType.DATATABLE],
    contextPermits: [kw.Permits.canRead],
    handler: function(actionArgs) {
        kw.ActionManager.showDialog(kw.Dialog.DatatableExport, actionArgs);       
    }
});


kw.Action.Datatable.Previous = new kw.Action({
    aid: "kw.Action.Datatable.Previous",
    template: kw.Action.Datatable.buttonTemplate,
    cls: "kw-dt-prev-spacer",
    iconCls:"kw-dt-entry-previous",
    tooltip:kw.Strings.Datatable.PreviousTip,
    contextTypes: [kw.MetaType.ROW, kw.MetaType.SCHEMA],
    getEnablement:function(actionArgs, summary){
        var rc = kw.widget.datatable.getRowControlForWidget(actionArgs.component);
        if (!rc || !rc.dtStore || (rc.getMode() != kw.widget.datatable.VIEW_MODE))
            return kw.Enablement.HIDE;
        if (rc.isPreviousBtnDisabled())
            return kw.Enablement.DISABLE;
        return kw.Enablement.ENABLE;
    },
    getResources: function(actionArgs, summary){
        var rc = kw.widget.datatable.getRowControlForWidget(actionArgs.component);
        var dtProps = actionArgs.context.getDataTableProperties();
        if (dtProps)
            return {tooltip: this.tooltip + "<br>"+ rc.getNameOfNextOrPrevEntry(false), doTooltipUpdate: true};
        else {
            kw.Util.debugHere("no dt props");
            return {tooltip: ""};
        }
    },
    handler: function(actionArgs) {
        var rc = kw.widget.datatable.getRowControlForWidget(actionArgs.component);
        rc.displayPreviousEntry();
    }
});

kw.Action.Datatable.Next = new kw.Action({
    aid: "kw.Action.Datatable.Next",
    template: kw.Action.Datatable.buttonTemplate,
    cls: "kw-dt-next-spacer",
    iconAlign: "right",
    iconCls:"kw-dt-entry-next",
    tooltip:kw.Strings.Datatable.NextTip,
    contextTypes: [kw.MetaType.ROW, kw.MetaType.SCHEMA],
    getEnablement:function(actionArgs, summary){
        var rc = kw.widget.datatable.getRowControlForWidget(actionArgs.component);
        if (!rc || !rc.dtStore || (rc.getMode() != kw.widget.datatable.VIEW_MODE))
            return kw.Enablement.HIDE;
        if (rc.isNextBtnDisabled())
            return kw.Enablement.DISABLE;
        return kw.Enablement.ENABLE;
    },
    getResources: function(actionArgs, summary){
        var rc = kw.widget.datatable.getRowControlForWidget(actionArgs.component);
        var dtProps = actionArgs.context.getDataTableProperties();
        if (dtProps)
            return {tooltip: this.tooltip + "<br>"+ rc.getNameOfNextOrPrevEntry(true), doTooltipUpdate: true};
        else {
            kw.Util.debugHere("no dt props");
            return {tooltip: ""};
        }
    },
    handler: function(actionArgs) {
        var rc = kw.widget.datatable.getRowControlForWidget(actionArgs.component);
        rc.displayNextEntry();
    }
});

kw.Action.Datatable.GoToSummary = new kw.Action({
    aid: "kw.Action.Datatable.GoToSummary",
    template: kw.Action.Datatable.buttonTemplate,
    cls: "kw-dt-summary-spacer",
    iconAlign: "right",
    iconCls:"kw-go-to-summary",
    contextTypes: [kw.MetaType.ROW],

    getResources: function(actionArgs, summary){
        var dtProps = actionArgs.context.getDataTableProperties();
        if (dtProps)
            return {tooltip: String.format(kw.Strings.Datatable.summaryTip, dtProps.get("object_name"))};
        else {
            kw.Util.debugHere("no dt props");
            return {tooltip: ""};
        }
    },
    handler: function(actionArgs) {
        var dtProps = actionArgs.context.getDataTableProperties();
        if (dtProps) {
            var navToCtx = new kw.Context(actionArgs.context.getUrl());
            navToCtx.id = dtProps.get("r_object_id");
            navToCtx.queryString = "";

            if (!navToCtx.space)
                navToCtx.space = kw.RendEng.RepoPseudoSpaceName;
            
            var rc = kw.widget.datatable.getRowControlForWidget(actionArgs.component);
            if (!rc || !rc.dtStore || (rc.getMode() != kw.widget.datatable.VIEW_MODE))
                kw.PagingToolbar.clearSavedGridPage();
            
            kw.RendEng.navigate(navToCtx);
            return;
        }
        kw.Util.debugHere("expected dt properties");
    }
});


kw.Action.DatatablePageMenu = new kw.Action({
	aid: "kw.Action.DatatablePageMenu",
    iconCls:"kw-am-DATATABLE",
    menuAlign: "tr-br?",
    getResources:function(actionArgs){
        var metatype = actionArgs.context.getContextProperties().getMetaType();
        return {text: kw.Util.getTypeSpecificString(kw.Strings.Action.PageMenu._tbl, metatype)};
    },
    menuContainer: "kw.Action.DatatablePageMenu"
});

kw.Action.DatatableEntryPageMenu = new kw.Action({
	aid: "kw.Action.DatatableEntryPageMenu",
    iconCls:"kw-am-ROW",
    menuAlign: "tr-br?",
	text: kw.Strings.Action.DatatableEntryActions._text,
    menuContainer: "kw.Action.DatatableEntryPageMenu"
});

kw.Action.ShowView_DatatableHome = new kw.Action({
    aid: "kw.Action.ShowView_DatatableHome",
    text: kw.Util.getTypeSpecificString(kw.Strings.ShowHome._tbl, kw.MetaType.DATATABLE),
    iconCls: "kw-dt-home kw-action-icon",
    contextPermits: [kw.Permits.canBrowse],
    handler: function(actionArgs) {
        var context = actionArgs.context.getContext();
        var meta = actionArgs.context.getContextProperties();
        context.id = meta.get("i_folder_id")[0].id;
        context.view = 'content';
        kw.RendEng.navigate(context);
    }
});

/////////////////////////////////////////////////////////////////////////////////////////////////////////


//Create Datatable
kw.Action.Datatable.Create = new kw.Action({
    aid: "kw.Action.Datatable.Create",
    iconCls:"kw-new-datatable",
    text: kw.Strings.Action.Pro.DatatableCreate._text,
    selectionTypes: [kw.MetaType.SPACE, kw.MetaType.FOLDER, kw.MetaType.DATATABLE, kw.MetaType.ROW],
    selectionPermits: [kw.Permits.canCreate],
    selectionGoverned: true,
    handler: function(actionArgs)  {
		kw.ActionManager.showDialog(kw.Dialog.DatatableCreate, actionArgs);
	}
});

kw.Action.Datatable.CreateForContext = new kw.Action({
    aid: "kw.Action.Datatable.CreateForContext",
    iconCls:"kw-new-datatable",
    text: kw.Strings.Action.Pro.DatatableCreate._text,
    contextTypes: [kw.MetaType.SPACE, kw.MetaType.FOLDER, kw.MetaType.DATATABLE, kw.MetaType.ROW],
    contextPermits: [kw.Permits.canCreate],    
    contextGoverned: true,
    getResources:function(actionArgs, summary, trigger){
        if (summary.menuaid.indexOf("kw.Action.NewItems")==-1)
            return kw.Util.formatContextMetaType (actionArgs, kw.Strings.New_tpl);
        return {};
    },
    handler: function(actionArgs)
    {
        actionArgs.selection=null;
		kw.ActionManager.showDialog(kw.Dialog.DatatableCreate, actionArgs);
    }
});                                                                                       

kw.Action.Datatable.CreateEntry = new kw.Action({
    aid: "kw.Action.Datatable.CreateEntry",
    iconCls:"kw-new-datatable-row  kw-action-icon",
    text: kw.Strings.Action.Pro.DatatableEntryCreate._text,
    selection: [kw.Select.SINGLE, kw.SelectModifier.HIDEMULTIPLE],
    selectionTypes: [kw.MetaType.DATATABLE],
    selectionPermits: [kw.Permits.canCreate],
    selectionGoverned:true,
    getResources:function(actionArgs, summary){
        if (!kw.Util.hasSelection(actionArgs)) return {};
        var strtbl=(summary.menuaid=="kw.Action.NewItemsMenu")?kw.Strings.Action.PageCreate._tbl: kw.Strings.Action.PageCreate._tblnew;
        var metatype=actionArgs.selection.items[0].metadata.getMetaType();
        return kw.MetaTypeUtil.getCreateInThisResources(metatype, strtbl, kw.Strings.Action.PageCreate._tbltooltip);
    },
    getEnablement: function(actionArgs, summary) {
        var lo = actionArgs.context.getContextProperties().get("r_lock_owner");
        return lo ? kw.Enablement.DISABLE : kw.Enablement.ENABLE;
    },
    handler: function(actionArgs)
    {
        kw.DatatableLib.CreateRow(actionArgs);
    }
});

kw.Action.Datatable.CreateInThis = new kw.Action({
    aid: "kw.Action.Datatable.CreateInThis",
    tooltip: kw.Strings.Datatable.newEntryTip,
    iconCls:"kw-new-datatable-row  kw-action-icon kw-accelerator-n-target",
    text: kw.Strings.Action.Pro.DatatableEntryCreate._text,
    contextTypes: [kw.MetaType.DATATABLE, kw.MetaType.ROW],
    contextGoverned:true,
    getEnablement:function(actionArgs, summary){
        var meta = actionArgs.context.getContextProperties();
        var metatype = meta.getMetaType();
        var permits, lo;
        if (metatype==kw.MetaType.ROW){
            meta=actionArgs.context.getDataTableProperties();
        }
        lo = meta.get("r_lock_owner");
        permits = meta.get("_kw_permits");
        return lo || !permits[kw.Permits.canCreate] ? kw.Enablement.DISABLE : kw.Enablement.ENABLE;
    },
//    getEnablement:function(actionArgs, summary){
//        var meta = actionArgs.context.getContextProperties();
//        var metatype = meta.getMetaType();
//        var permits, lo;
//        lo = meta.get("r_lock_owner");
//        permits = meta.get("_kw_permits");
//        if (metatype==kw.MetaType.ROW){
//            lo="";
//            permits = meta.get("_kw_container_permits");
//        }
//        return lo || !permits[kw.Permits.canCreate] ? kw.Enablement.DISABLE : kw.Enablement.ENABLE;
//    },
    handler: function(actionArgs)
    {
        kw.DatatableLib.CreateRow(actionArgs);
    }
});


kw.Action.Datatable.GlobalCreate = new kw.Action({
    aid: "kw.Action.Datatable.GlobalCreate",
    iconCls:"kw-new-datatable",
    text: kw.Strings.Action.Pro.DatatableCreate._text,
    handler: function(actionArgs)
    {
        kw.DatatableLib.globalDatatableCreate(actionArgs, kw.MetaType.DATATABLE);
    }
});

kw.Action.Datatable.GlobalRecentEntries = new kw.Action({
    aid: "kw.Action.Datatable.GlobalRecentEntries",
    iconCls:"kw-datatableEntryRecent16",
    text: kw.Strings.Datatable.RecentActivity.recentEntries,
    cls: "kw-community-global-menu-items",
    handler: function(actionArgs){
        var clickContext = Ext.apply({}, actionArgs.context);
        clickContext.repository =  actionArgs.context.repository,
        clickContext.space = kw.RendEng.GlobalPseudoSpaceName,
        clickContext.view = "home",
        clickContext.id = "page";
        clickContext.pgview = "community_rEntries";
        kw.RendEng.navigate(clickContext);
    }
});

kw.Action.Datatable.EditSchema = new kw.Action({
    aid: "kw.Action.Datatable.EditSchema",
    iconCls:"kw-file-edit kw-action-icon",
    text: kw.Strings.Action.Pro.Datatable.EditSchema._text,
    tooltip: kw.Strings.Action.Pro.Datatable.EditSchema._tooltip,
    selection: [kw.Select.SINGLE, kw.SelectModifier.HIDEMULTIPLE],
    selectionTypes: [kw.MetaType.DATATABLE],
    selectionPermits: [kw.Permits.canEdit],
    selectionGoverned:true,
    getOverride:function(actionArgs){
        var meta;
        if (!kw.Util.hasSelection(actionArgs)) return false;
        meta = actionArgs.selection.items[0].metadata;
        if (meta.status &&meta.status!=kw.Status.LOADED) return false; // avoid access till loaded! 
        return (meta.getMetaType()==kw.MetaType.DATATABLE);
    },
    getEnablement:function(actionArgs, summary) {    // custom enablement (called if present)
        var metadata = actionArgs.context.getContextProperties();
        if (kw.Util.hasSelection(actionArgs))
            metadata = actionArgs.selection.items[0].metadata;
        var permits = metadata.get("_kw_permits");
        if (!permits[kw.Permits.canEdit]) return kw.Enablement.DISABLE; 
        var lockOwner = metadata.get("r_lock_owner");
        if (lockOwner && lockOwner != "")
            return kw.Enablement.HIDE;
        return kw.Enablement.ENABLE;
    },
    handler: function(actionArgs) {
        kw.DatatableLib.EditSchema(actionArgs);
    }
//    ,
//   enablementHooks: {
//        "kw.Action.Edit": function(actionArgs, summary) {
//            if (actionArgs.selection &&
//                actionArgs.selection.items.length &&
//               (actionArgs.selection.items[0].metadata.getMetaType() == kw.MetaType.DATATABLE))
//                    return kw.Action.Datatable.EditSchema.initialConfig.getEnablement.apply(this, arguments);
//
//            return kw.Action.Datatable.EditSchema.origEnablement["kw.Action.Edit"].apply(this, arguments);
//        }
//    }
});

//kw.Action.Datatable.EditSchema.hookEnablement(kw.Action.Edit);

kw.Action.Datatable.ImportEntries = new kw.Action({
    aid: "kw.Action.Datatable.ImportEntries",
    iconCls:"kw-dt-import kw-action-icon",
    text: kw.Strings.Action.Pro.DatatableEntriesImport._text,
    contextTypes: [kw.MetaType.DATATABLE],
    contextPermits: [kw.Permits.canCreate],
    contextGoverned:true,
    handler: function(actionArgs) {
        kw.ActionManager.showDialog(kw.Dialog.DatatableImport, actionArgs);        
    }
});

kw.Action.Datatable.ExpandCollapse = new kw.Action({
    aid: "kw.Action.Datatable.ExpandCollapse",
    cls:"kw-db-expand-collapse-btn x-tool x-tool-up",
    getEnablement:function(actionArgs, summary){
        var pc = kw.widget.PageControl.getPageControlForWidget(actionArgs.component);
        var metaType = pc.context.getContextProperties().getMetaType();
        if (metaType == kw.MetaType.ROW || metaType == kw.MetaType.SCHEMA){
            return kw.Enablement.ENABLE;
        }
		return kw.Enablement.HIDE;
	},
    handler: function(actionArgs)
    {
        var trigger = actionArgs._trigger;
        var contextNode = trigger.el.findParentNode('.context_node', 35, true);
        var pageContentArea = contextNode.child('.page-content-area');
        var dbPane = pageContentArea.child('.kw-scrollbox-markerforpage');
        var dbPaneBody = dbPane.first().first();
        var dbPaneBodyHeight = dbPaneBody.getHeight();

        if (trigger.el.hasClass('x-tool-up') || dbPaneBodyHeight)
        {
            trigger.removeClass('x-tool-up');
            trigger.addClass('x-tool-down');
            dbPaneBody._savedHeight = dbPaneBody.getHeight();
            dbPaneBody.setHeight(0);
        }
        else
        {

            trigger.removeClass('x-tool-down');
            trigger.addClass('x-tool-up');
            dbPaneBody.setHeight(dbPaneBody._savedHeight);
        }
        var cmp = Ext.getCmp(pageContentArea.id);
        cmp.doLayout();
    }
});

kw.Action.Datatable.Filter = new kw.Action({
    aid: "kw.Action.Datatable.Filter",
    createTrigger:function (containername, actionArgs, triggerDef, summary){
        rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/DtFilter.js");
        return new kw.widget.datatable.SearchTool({actionArgs: actionArgs});
    }
});

kw.Action.Datatable.FilterStatus = new kw.Action({
    aid: "kw.Action.Datatable.FilterStatus",
    createTrigger:function (containername, actionArgs, triggerDef, summary){
        return new kw.widget.datatable.FilterStatus({actionArgs: actionArgs, text: ""});
    }
});

kw.Action.Datatable.SearchFilterExpStr = new kw.Action({
    aid: "kw.Action.Datatable.SearchFilterExpStr",
    createTrigger:function (containername, actionArgs, triggerDef, summary){
        return new kw.widget.datatable.SearchFilterExpStr({actionArgs: actionArgs, text: ""});
    }
});

kw.Action.Datatable.ClearFilter = new kw.Action({
    aid: "kw.Action.Datatable.ClearFilter",
    createTrigger:function (containername, actionArgs, triggerDef, summary){
        return new kw.widget.datatable.ClearFilter({actionArgs: actionArgs});
    }
});

kw.Action.Datatable.AddFieldsToTable = new kw.Action({
	aid: "kw.Action.Datatable.AddFieldsToTable",
	iconCls: "kw-pageedit-addwidget",
	text: kw.Strings.Action.Pro.Datatable.AddField._text,
	tooltip: kw.Strings.Action.Pro.Datatable.AddField._tooltip,
    handler: function(actionArgs) {
        var tab = kw.RendEng.getTabManager().getActiveTab();
        if (tab) {
            var pc = kw.widget.PageControl.getPageControl(tab.el.dom);
            if (pc) {
                pc.fireEvent("adddtwidget");
            }
        }
    }
});

kw.Action.Datatable.CancelConfigEdit = new kw.Action({
    aid: "kw.Action.Datatable.CancelConfigEdit",
    createTrigger:function (containername, actionArgs, triggerDef, summary){
        return new Ext.Toolbar.Button({
            text: kw.Strings.Action.CancelPageEdit._text,
            tooltip: kw.Strings.Action.DatatableCancelConfigEdit._tooltip,
            template: kw.Action.Page.buttonTemplate,
            baseAction: kw.Action.Datatable.CancelConfigEdit,
            handler: kw.ActionManager.handler,
            _handler: function(actionArgs) {
                actionArgs.component.pageControl.unlockPage(actionArgs);
            }
        });}
});

kw.Action.Datatable.EditEntryFromGrid = new kw.Action({
    aid: "kw.Action.Datatable.EditEntryFromGrid",
    iconCls:"kw-file-edit kw-action-icon",
    text: kw.Strings.Action.Pro.EditEntry._text,
    tooltip: kw.Strings.Action.Pro.EditEntry._tooltip,
    selectionTypes:[kw.MetaType.ROW],
    selectionGoverned:true,    
    getOverride:function(actionArgs){
        if (!kw.Util.hasSelection(actionArgs)) return false;
        var meta = actionArgs.selection.items[0].metadata;
        if (meta.status &&meta.status!=kw.Status.LOADED) return false; // avoid access till loaded!
        return (meta.getMetaType()==kw.MetaType.ROW);
    },
    getResources: function(actionArgs, summary){
        if (!kw.Util.hasSelection(actionArgs)) return null;
        var metadata = actionArgs.selection.items[0].metadata;
        var metatype = metadata.getMetaType();
        var res;
        if (metatype == kw.MetaType.FILE || (kw.MetaTypeUtil.isPage(metatype) && kw.isPro())){
            if (summary.containername && summary.containername.indexOf(".bubble.")>=0){
                res={text: kw.Strings.Action.Edit._text};
            }
            else{
                res={text: kw.Util.getTypeSpecificStringSel(kw.Strings.Action.Edit._tbl, actionArgs)};
            }
        } else{
            res={text: kw.Strings.Action.Edit._text};
        }
        var lock =metadata.get("r_lock_owner");
        if(lock && lock!=kw.User.getUserName(actionArgs.context) && !kw.User.isCoordinator(actionArgs.context,metadata)){
            res.iconCls = "kw-locked-page";
            res.tooltip = String.format(kw.Strings.Action.Edit._lockbyothertooltip, metadata.get("r_lock_owner"), Ext.util.Format.date(metadata.get("r_lock_date"), kw.Strings.DateFormats.date_month_name));
        }
        return res;
    },
    getEnablement: function(actionArgs, summary){
        if (summary.selectionCount==0) return kw.Enablement.DISABLE;
        var counts = kw.MetaTypeUtil.getUnlockOrCancelCounts(actionArgs, summary);
        if (counts.ufiles+counts.cfiles == summary.selectionCount)
            return kw.Enablement.HIDE;  // replaced by unlock/cancel edit
        else if (counts.upages+counts.cpages == summary.selectionCount == 1)
            return kw.Enablement.HIDE;  // replaced by unlock/cancel edit
        if (summary.selectionCount>1) return kw.Enablement.SUPPRESS;
        var metadata = actionArgs.selection.items[0].metadata;
        var metatype = metadata.getMetaType();
        var lock =metadata.get("r_lock_owner");
        if(lock!="" && lock!=kw.User.getUserName(actionArgs.context) && !kw.User.isCoordinator(actionArgs.context,metadata))
            return kw.Enablement.DISABLE;
        var permits = metadata.get("_kw_permits");
        if (metatype==kw.MetaType.FILE || (kw.MetaTypeUtil.isPage(metatype) && kw.isPro()
                && metatype!=kw.MetaType.DATATABLE) ) {   // dlm todo; resolve various edit actions
            return permits[kw.Permits.canEdit]? kw.Enablement.ENABLE : kw.Enablement.DISABLE;
        }
        return kw.Enablement.SUPPRESS;
    },
    handler: function(actionArgs){
        var selection = actionArgs.selection;
        var newContext = selection.getContext(selection.items[0]);
        var metaType = newContext.getContextProperties().getMetaType();
        newContext.view = (metaType == kw.MetaType.SPACEHOMEPAGE) ? 'home' : 'content';
        if (actionArgs.component && actionArgs.component.preNavigate)
            actionArgs.component.preNavigate(newContext);
        kw.DatatableLib.navigateEditMode(newContext, Ext.emptyFn, this);
    }
});

kw.Action.Datatable.EditEntry = new kw.Action({
    aid: "kw.Action.Datatable.EditEntry",
    iconCls:"kw-file-edit kw-action-icon",
    text: kw.Strings.Action.Pro.EditEntry._text,
    tooltip: kw.Strings.Action.Pro.EditEntry._tooltip,
    contextGoverned:true,
    getEnablement:function(actionArgs, summary) {
        var meta = actionArgs.context.getContextProperties();
        var metaType = meta.getMetaType();
        if (metaType == kw.MetaType.ROW) {
            var lockowner = meta.get('r_lock_owner');
            var permits = meta.get('_kw_permits');
            var dbmeta = actionArgs.context.getDataTableProperties();
            if (lockowner == "" || (lockowner!=kw.User.getUserName(actionArgs.context) && !kw.User.isCoordinator(actionArgs.context,meta))) {
// dlm: if table is locked, we can't edit or create!
// should we put table lock info in tooltip??
                return dbmeta.get("r_lock_owner")=="" && permits[kw.Permits.canEdit] ? kw.Enablement.ENABLE : kw.Enablement.DISABLE;
            }
            else {
                return kw.Enablement.HIDE;
            }
        }
        return kw.Enablement.ENABLE;
    },
//    getEnablement:function(actionArgs, summary) {
//        var meta = actionArgs.context.getContextProperties();
//        var metaType = meta.getMetaType();
////        var lockowner = meta.get('r_lock_owner');
////        if (lockowner == "" || (lockowner!=kw.User.getUserName(actionArgs.context) && )) {
//        var permits = meta.get('_kw_permits');
//        if (!permits[kw.Permits.canEdit] && !kw.User.isCoordinator(actionArgs.context,meta)){
//            return Enablement.ENABLE;
//        }
//        else {
//            return kw.Enablement.HIDE;
//        }
//    },
    getResources:function(actionArgs, summary){
        var meta = actionArgs.context.getContextProperties();
        var metaType = meta.getMetaType();
        if (metaType == kw.MetaType.ROW) {
            var lockowner = meta.get('r_lock_owner');
            if (lockowner!=""){
                var lockedOn = meta.get('r_lock_date');
                return {iconCls:"kw-locked-page",
                        tooltip:String.format(kw.Strings.Action.Pro.PageLockedBy._tooltip, lockowner, lockedOn)};
            }
        }
        return {};
    },
    handler: function(actionArgs) {
        kw.DatatableLib.EditRow(actionArgs);
    }
});

kw.Action.Datatable.SaveEntry = new kw.Action({
    aid: "kw.Action.Datatable.SaveEntry",
    createTrigger:function (containername, actionArgs, triggerDef, summary){
        return new Ext.Toolbar.Button({
            text: kw.Strings.Action.Pro.SaveEntry._text,
            tooltip: kw.Strings.Action.Pro.SaveEntry._tooltip,
            cls: "kw-pagetoolbarbtn-bold",
            template: kw.Action.Datatable.buttonTemplate,
            baseAction: kw.Action.Datatable.SaveEntry,
            handler: kw.ActionManager.handler,
            _handler: function(actionArgs) {
                var rc = kw.widget.datatable.getRowControlForWidget(actionArgs.component);
                rc.saveRow(actionArgs);
            }
        });
    }    
});

kw.Action.Datatable.SaveEntryAddAnother = new kw.Action({
    aid: "kw.Action.Datatable.SaveEntryAddAnother",
    getEnablement:function(actionArgs){
        var meta=actionArgs.context.getContextProperties();
        var permits = (meta.getMetaType()==kw.MetaType.DATATABLE) ?
                      meta.get("_kw_permits") : meta.get("_kw_container_permits");
        return (!permits || !permits.canCreate) ? kw.Enablement.DISABLE : kw.Enablement.ENABLE;
    },
    createTrigger:function (containername, actionArgs, triggerDef, summary){
        return new Ext.Toolbar.Button({
            text: kw.Strings.Action.SaveEntryAddAnother._text,
            tooltip: kw.Strings.Action.SaveEntryAddAnother._tooltip,
            template: kw.Action.Datatable.buttonTemplate,
            baseAction: kw.Action.Datatable.SaveEntryAddAnother,
            handler: kw.ActionManager.handler,
            _handler: function(actionArgs) {
                var rc = kw.widget.datatable.getRowControlForWidget(actionArgs.component);
                function fnContinue(){
                    kw.ActionManager.dispatch(kw.Action.Datatable.CreateInThis, actionArgs);
                }
                rc.saveRow(actionArgs, fnContinue);
            }
        });
    }
});

/**
 * NOTE : This is used on page toolbar ONLY; not on selection
 */
kw.Action.Datatable.CancelEntryEdit = new kw.Action({
    aid: "kw.Action.Datatable.CancelEntryEdit",
    createTrigger:function (containername, actionArgs, triggerDef, summary){
        return new Ext.Toolbar.Button({
            text: kw.Strings.Action.Pro.CancelEntryEdit._text,
            tooltip: kw.Strings.Action.Pro.CancelEntryEdit._tooltip,
            template: kw.Action.Datatable.buttonTemplate,
            baseAction: kw.Action.Datatable.CancelEntryEdit,
            handler: kw.ActionManager.handler,
            _handler: function(actionArgs) {
                var meta = actionArgs.context.getContextProperties();
                var metaType = meta.getMetaType();
                var rc = kw.widget.datatable.getRowControlForWidget(actionArgs.component);
                var functCancel, msgTitle, msgBody;
                if (metaType == kw.MetaType.ROW) {                    
                    functCancel = function(buttonId) {
                            if (buttonId == "yes") {
                                rc.cancelEditEntry(actionArgs);
                            }else{
                                return false;
                            }
                        };
                        msgTitle = kw.Strings.Datatable.entryNavigateAwayTitle;
                        msgBody = kw.Strings.Datatable.cancelEditEntry;
                        kw.MessageBox.show({
                            title:  msgTitle,
                            msg:    msgBody,
                            buttons: Ext.MessageBox.YESNO,
                            icon:    Ext.MessageBox.WARNING,
                            cls:     'kw-msg-alert',
                            fn:  functCancel.createDelegate(this)
                                }, null);
                }
                else {
                        functCancel = function(buttonId) {
                            if (buttonId == "yes") {
                                actionArgs.context.queryString = "";
                                rc.onNavigateWithNoNavHook = actionArgs.context;
                                kw.RendEng.navigate(actionArgs.context);
                                rc.onNavigateWithNoNavHook = null;
                            }else{
                                return false;
                            }
                        };
                        msgTitle = kw.Strings.Datatable.newEntryNavigateAwayTitle;
                        msgBody = kw.Strings.Datatable.cancelEditNewEntry;
                        kw.MessageBox.show({
                            title:  msgTitle,
                            msg:    msgBody,
                            buttons: Ext.MessageBox.YESNO,
                            icon:    Ext.MessageBox.WARNING,
                            cls:     'kw-msg-alert',
                            fn:  functCancel.createDelegate(this)
                                }, null);

                }
            }
        });
    }
});

kw.Action.Datatable.SaveSchema = new kw.Action({
    aid: "kw.Action.Datatable.SaveSchema",
    text: kw.Strings.Action.SaveSchema._text,
    tooltip: kw.Strings.Action.SaveSchema._tooltip,
    cls: "kw-pagetoolbarbtn-bold",
    template: kw.Action.Datatable.buttonTemplate,
    handler: function(actionArgs) {
        var rc = kw.widget.datatable.getRowControlForWidget(actionArgs.component);
        rc.saveSchema(actionArgs);
    }
});

kw.Action.Datatable.ResetToContainerPermissions = new kw.Action({
    aid: "kw.Action.Datatable.ResetToContainerPermissions",
    text: kw.Strings.Action.ResetToParentPermissions._text,
    contextGoverned: true,
    getEnablement: function(actionArgs, summary) {
        if (actionArgs.readOnlyPermissions)
        {
            return kw.Enablement.HIDE;
        }
        if (actionArgs.permissionsMatchContainer)
        {
            return kw.Enablement.HIDE;
        }
        else
        {
            return kw.Enablement.ENABLE;
        }
    },
    handler: function(actionArgs) {
       kw.ActionLib.resetToParentPermissions(actionArgs);
    }
});

kw.Action.NewItemsDTSubMenu = new kw.Action({
	aid: "kw.Action.NewItemsDTSubMenu",
    text: kw.Strings.Action.New._text,
    iconCls:"kw-new16",
    selection: [kw.Select.SINGLE, kw.SelectModifier.HIDEMULTIPLE],
    selectionTypes: [kw.MetaType.FOLDER],  //, kw.MetaType.DATATABLE
    contextTypes: [kw.MetaType.DATATABLE],
    menuContainer: "kw.Action.NewItemsSubMenu"
});
kw.Action.NewItemsDTBKSubMenu = new kw.Action({
	aid: "kw.Action.NewItemsDTBKSubMenu",
    text: kw.Strings.Action.New._text,
    iconCls:"kw-new16",
    selection: [kw.Select.SINGLE, kw.SelectModifier.HIDEMULTIPLE],
    selectionTypes: [kw.MetaType.FOLDER, kw.MetaType.DATATABLE, kw.MetaType.ROW],
    contextTypes: [kw.MetaType.DATATABLE],
    menuContainer: "kw.Action.NewItemsSubMenu"
});
kw.Action.DatatableMoreMenu = new kw.Action({
	aid: "kw.Action.DatatableMoreMenu",
    text: kw.Strings.Action.MoreMenu._text,
    tooltip: kw.Strings.Action.MoreMenu._tooltip,
    menuContainer: "kw.Action.DatatableMoreMenu"
});


// Add type specific handlers for common actions.
kw.ActionRegistry.override(kw.Action.Edit, kw.Action.Datatable.EditSchema);
kw.ActionRegistry.override(kw.Action.Edit, kw.Action.Datatable.EditEntryFromGrid);


/* DataTableColumnModel.js */

(function() {

    Ext.namespace("kw.widget.datatable");

    var _renderColumnFunctions = {};
    var renderingColumnViewClass = {};

    function _defaultRenderColumn(value, metadata, record, rowIndex, colIndex, store) {
        return Ext.util.Format.htmlEncode(value);
    }

    // Get static method defined on View class associated with widgetType.  For example,
    // if widgetType == 'cma.kw.form.PlainText', then the associated renderer function is
    // cma.kw.form.PlainTextView.renderDataTableColumn.  If the associated View class does not
    // define such a function, then the _defaultRenderColumn function defined above is used.
    function _getRenderColumnFunction(widgetType, isPrimaryColumn) {
        if (isPrimaryColumn)
        {
            var primColViewClass = _getRenderingViewClass(widgetType);
            if (primColViewClass != null && typeof(primColViewClass.renderAsDataTablePrimaryColumn) == 'function')
            {
                return primColViewClass.renderAsDataTablePrimaryColumn;
            }
            else
            {
                return _getRenderColumnFunction(widgetType, false);
            }
        }
        else if (!_renderColumnFunctions[widgetType])
        {
            var viewClass = _getRenderingViewClass(widgetType);
            if (viewClass != null)
            {
                if (viewClass && typeof(viewClass.renderDataTableColumn) == 'function')
                    _renderColumnFunctions[widgetType] = viewClass.renderDataTableColumn;
                else
                    _renderColumnFunctions[widgetType] = _defaultRenderColumn;
            }
            else
            {
                _renderColumnFunctions[widgetType] = _defaultRenderColumn;
            }
        }
        return _renderColumnFunctions[widgetType];
    }

    //kwc-8405
    function _getRenderingViewClass(widgetType) {
        var cd = rcmp.ComponentRegistry.getComponentDefinition(widgetType);
        //kwc-7212, for automation testing, CStage needs to do print/render for non-implemented widgets
        if (cd != null)
        {
            if (!renderingColumnViewClass[widgetType])
            {
                var ns = cd.getURLNameSpace();
                var index = widgetType.lastIndexOf('.');
                var baseClassPath = widgetType.substring(0, index);
                var viewClassName = widgetType.substring(index + 1) + 'View';
                var url = rcmp.core.Environment.makeURL(ns, 'js/' + viewClassName + '.js');
                rcmp.resource.ResourceLoader.loadJS(url);
                renderingColumnViewClass[widgetType] = kw.Util.evalDotPath(baseClassPath + '.' + viewClassName);
            }
            return renderingColumnViewClass[widgetType];
        }
        return null;
    }

    /*
     * DataTableColumnModel
     * Base class for datatable entry column model
     */
    kw.widget.datatable.DataTableColumnModel = Ext.extend(kw.widget.ItemListColumnModel, {

        constructor: function(listMetadata, context, columnHeaderHidden, prefSettings) {
            kw.widget.datatable.DataTableColumnModel.superclass.constructor.call(this,
                    listMetadata,
                    context,
                    columnHeaderHidden,
                    prefSettings);

            // For data table summary page, we want "r_creation_date" to be the last column & hidden.
            var colCount = this.getColumnCount();
            var colIndex = this.getIndexById("r_creation_date");
            if (colIndex != -1) {
                // Hide "r_creation_date" column if there is no hidden column preferences.
                if (this.prefSettings && this.prefSettings.hiddenColumnsPrefName && this.prefSettings.preferences &&
                    typeof(this.prefSettings.preferences[this.prefSettings.hiddenColumnsPrefName]) == 'undefined')
                    this.setHidden(colIndex, true);

                // Move "r_creation_date" to the end if there is no column order preferences.
                var orderedColumns = null;
                if (this.prefSettings && this.prefSettings.orderedColumnsPrefName)
                    orderedColumns = Ext.util.JSON.decode(this.prefSettings.preferences[this.prefSettings.orderedColumnsPrefName]);
                if ((orderedColumns == null) && (colIndex < colCount - 1)) {
                    this.ignoreMoveEvent = true; // kwc-8702 -- avoid inadvertent creation of column order preference
                    this.moveColumn(colIndex, colCount - 1);
                    this.ignoreMoveEvent = false;
                }
            }

            this._primaryColId = null;
            var columnDefinitions = this.columnDefinitions = listMetadata.columnDefinition;
            var bSetDefaultWidths =
                    (!prefSettings || !prefSettings.preferences || !prefSettings.preferences.ColumnsWidth);

            this.calculateTotalDefaultWidth(columnDefinitions);

            for (var i = 0; i < columnDefinitions.length; i++) {
                var colDef = columnDefinitions[i];

                // A datatable column's type will be a widget ID for that column type
                var fieldId = colDef.renderType;
                if (fieldId && fieldId.indexOf("cma.kw.form.") != -1)
                {
                    if (colDef.primary)
                        this._primaryColId = colDef.columnName;
                    colIndex = this.getIndexById(colDef.columnName);
                    if (colIndex == -1)
                        continue;   // column not displayed; skip

                    this.setRenderer(colIndex, _getRenderColumnFunction(fieldId, colDef.primary));
                    if (fieldId == "cma.kw.form.AutonumberField" ||
                        fieldId == "cma.kw.form.NumberField")
                        this.config[colIndex].align = "right";

                    // if there's a defined default width for the current column type, use it.
                    if (bSetDefaultWidths && colDef.multiValue && (defaultColumnWidths[fieldId].multi !== false)) {
                        this.config[colIndex].width = defaultColumnWidths[fieldId].multi;
                    }
                    else if (bSetDefaultWidths && !colDef.multiValue && (defaultColumnWidths[fieldId].single !== false)) {
                        this.config[colIndex].width = defaultColumnWidths[fieldId].single;
                    }
                }
            }
        },

        onColumnMoved: function() {
            if (!this.ignoreMoveEvent)
                kw.widget.datatable.DataTableColumnModel.superclass.onColumnMoved.apply(this, arguments);
        },

        calculateTotalDefaultWidth: function(columnDefinitions) {
            var totalDefaultWidth = 0;
            if (!columnDefinitions)
                columnDefinitions = this.columnDefinitions;

            for (var i = 0; i < columnDefinitions.length; i++) {
                var colDef = columnDefinitions[i];

                // A datatable column's type will be a widget ID for that column type
                var fieldId = colDef.renderType;
                if (fieldId && fieldId.indexOf("cma.kw.form.") != -1)
                {
                    colIndex = this.getIndexById(colDef.columnName);
                    if (colIndex == -1)
                        continue;   // column not displayed; skip

                    // If we haven't recorded the default width for the column locally, get the
                    // display config and initialize the local table.
                    if (typeof defaultColumnWidths[fieldId] == "undefined") {
                        defaultColumnWidths[fieldId] = {single: false, multi: false};
                        var dspcfg = kw.RcmpBinding.getDisplayConfig(fieldId);
                        var cfgVal = dspcfg.attributes.defaultColumnWidth;
                        if (cfgVal) {
                            // if the display config defines both single and multi widths, the
                            // widths (numbers) are separated by a comma in the attribute value.
                            cfgVal = cfgVal.split(",");
                            if (cfgVal.length == 1) {
                                defaultColumnWidths[fieldId].single = parseInt(cfgVal);
                            }
                            else if (cfgVal.length == 2) {
                                defaultColumnWidths[fieldId].single = parseInt(cfgVal[0]);
                                defaultColumnWidths[fieldId].multi = parseInt(cfgVal[1]);
                            }
                            else kw.Util.debugHere("unexpected");
                        }
                    }

                    // if there's a defined default width for the current column type, use it.
                    if (!isHidden.call(this, colDef)) {
                        if (colDef.multiValue && (defaultColumnWidths[fieldId].multi !== false)) {
                            totalDefaultWidth += defaultColumnWidths[fieldId].multi;
                        }
                        else if (!colDef.multiValue && (defaultColumnWidths[fieldId].single !== false)) {
                            totalDefaultWidth += defaultColumnWidths[fieldId].single;
                        }
                    }
                }
            }
            this.totalDefaultWidth = totalDefaultWidth;
            kw.Util.debug("the dt grid width is ", totalDefaultWidth);
            return totalDefaultWidth;
        }
    });

    var defaultColumnWidths = {};

    function isHidden(colDef) {
        for (var colIndex in this.config) {
            cfgItem = this.config[colIndex];
            if (cfgItem.id == colDef.columnName) {
                if (typeof (cfgItem.hidden) != "undefined") {
                    return cfgItem.hidden;
                }
                break;
            }
        }
        return true;
    }

})();

/* DatatableCreate.js */

rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/DatatableLib.js");

kw.ScriptLoader.require("js/kw/Dialog/WizardBase.js");
kw.ScriptLoader.require("js/kw/widget/Literal.js");
kw.ScriptLoader.require("js/kw/widget/form/FieldPlugIn.js");
kw.ScriptLoader.require("js/kw/widget/form/Select.js");
kw.ScriptLoader.require("js/kw/widget/form/MultiValue.js");
kw.ScriptLoader.require("js/kw/widget/form/IconCombo.js");
kw.ScriptLoader.require("js/kw/widget/form/LiteralField.js");
kw.ScriptLoader.require("js/kw/widget/form/RichEdit.js");

Ext.namespace('kw.Dialog');

kw.Dialog.DatatableCreate = function(config)
{
    if (typeof config == "undefined") config = {};
    kw.ScriptLoader.requireStrings("DatatableCreate");

    this.establishContext(config);

    // Load the dt templates
    this.templatesStore = new kw.data.Store({
                proxy:   new kw.data.DWRProxy(ListService.fetchResults),
                reader:  new kw.data.ServiceResultsReader(),
                queryId: "active_datatable_templates",
                remoteSort: true,
                context: this.context
    });

    this.categoriesStore = new Ext.data.SimpleStore({
        fields: [ "a_template_category", "a_template_category_text"]
    });

    // Create the XTemplates
    var categories_tpl = new Ext.XTemplate(
                '<tpl for=".">',
                    '<div class="kw-category">',
                    '{[this.enc(values.a_template_category_text)]}</div>',
                '</tpl>',
                {
                    enc: function(value) {
                        return kw.Util.retainWhiteSpaces(Ext.util.Format.htmlEncode(value));
                    }
                }
    );

    var templates_tpl = new Ext.XTemplate(
                '<tpl for=".">',
                    '<div class="kw-template" id="{values.r_object_id}">',
                        '<table ><tr>',                            
                            '<td class="kw-new-page-template-image-cell"><img  src="{[this.getImgSrc(values)]}" class="icon"></td>',
                            '<td class="kw-new-page-template-body-cell"><input type="hidden" name="template_location" value="{values._kw_primary_location}">' +
                                '<span class="kw-new-page-template-title">{[this.enc(this.truncateString(values.object_name,60))]}</span><br><span class="kw-new-page-template-body">{[this.enc(values.subject)]}</span></td>',
                        '</tr></table>',                                                                                     
                    '</div>',
                '</tpl>',
                {
                    enc: function(value) {
                        return Ext.util.Format.htmlEncode(value);
                    },
                    getImgSrc: function(values) {
                        var info = kw.Util.getImgUrlInfo(values._kw_icon,0);
                        return info.url;
                    },
                    truncateString : function(stringValue,length){
                        return Ext.util.Format.ellipsis(stringValue,length);
                    } //KWC-3134
                }
    );

    //Create dataviews for DT templates & template categories
     this.categoriesView = new Ext.DataView({
                                cls: "kw-category-selector",
                                store: this.categoriesStore,
                                tpl: categories_tpl,
                                autoHeight:true,
                                singleSelect: true,
                                itemSelector:'div.kw-category',
                                emptyText: kw.Strings.NoImagesToDisplay,

                                listeners:
                                {
            	                    selectionchange:
                                    {
                                        fn: function(dv, selections) {
                                            
                                            var index = dv.getSelectedIndexes();
                                            var category = dv.store.getAt(index).data.a_template_category;
                                            function filter(record, id){
                                                var a = false;
                                                if (record.get("a_template_category") === category)
                                                    a = true;
                                                return a;
                                            }
                                            if (category == kw.Strings.Dialog.DatatableCreate.all)
                                            {
                                                this.templatesStore.filter('a_template_category', "");
                                            }
                                            else
                                            {
                                                this.templatesStore.filterBy(filter, this);
                                            }

                                            // if we have items in the list and nothing is selected then we are going
                                            // to select the first item.
                                            if (this.templatesStore.getCount()>0 && this.templatesView.getSelectionCount()==0)
                                            {
                                                this.templatesView.select(0);
                                            }
                                        },
                                        scope:this
                                    }
                                }
                            })
    this.categoriesView.on("containerclick", this.onTemplateSelectorContainerClick, this);
    this.categoriesView.on("beforeclick", this.onTemplateSelectorBeforeClick, this);

    //use customized dataview class to support preview panel
    var templateConfig = {
        cls: "kw-template-selector",
        store: this.templatesStore,
        tpl: templates_tpl,
        autoHeight:true,
        singleSelect: true,
        itemSelector:'div.kw-template',
        emptyText: kw.Strings.NoImagesToDisplay
    };

    templateConfig = kw.bubble.updateConfigForCreateFromTemplateDlg(templateConfig, config);

    this.templatesView = new kw.bubble.templateIconView(templateConfig);

    this.templatesView.on("containerclick", this.onTemplateSelectorContainerClick, this);
    this.templatesView.on("beforeclick", this.onTemplateSelectorBeforeClick, this);
    this.templatesView.on("selectionchange", this.onTemplateChange, this);

    var fieldSetConfig = {
        border: false,
        autoScroll:true,
        autoWidth:true,
        cls: "kw-page-choose-template"
    };

    var card1Config = {
        items: [
            {xtype: "label", html: "<div class='kw-dlg-step-label'>" + kw.Strings.Dialog.DatatableCreate.step1of2 + "<hr/></div>" },
            {xtype: "textfield", fieldLabel: kw.Strings.Dialog.DatatableCreate.dtname, name: "object_name", allowBlank: false,
                    blankText: kw.Strings.Dialog.DatatableCreate.dtname_required_warning,
                    validator: kw.Util.maxLengthByteValidator,
                    regex: new RegExp("^[^\/]+$"), regexText: kw.Strings.Dialog.DatatableCreate.illegalCharErr,
                    required:true, maxLength: 255, width: 492,
                    plugins: new kw.widget.FieldPlugIn({helpText: kw.Strings.Dialog.DatatableCreate.uniquename})},
            {xtype: "label", text: kw.Strings.Dialog.DatatableCreate.choosedttemplate, cls: "kw-choose-template-label"},
            {xtype: "panel", cls: "kw-choose-template", border: false, width: 620, layout: "column",items: [this.categoriesView, this.templatesView]}
        ]
    };
    Ext.apply(card1Config, fieldSetConfig);
    this._card1 = new Ext.form.FieldSet(card1Config);

    var card2Config = {
        items: [
            {xtype: "label", html: "<div class='kw-dlg-step-label'>" + kw.Strings.Dialog.DatatableCreate.step2of2 + "<hr/></div>" },
            {xtype: "richedit", fieldLabel: kw.Strings.Dialog.DatatableCreate.welcomeMessage, anchor: kw.Dialog.defaults.anchor,
                name: "description", height: 120, plugins: new kw.widget.FieldPlugIn({helpText: kw.Strings.Dialog.DatatableCreate.descriptionHelptext})}
        ]
    };
    var fieldSetConfig_Card2 = {
        border: false,
        autoScroll:true,
        autoWidth:true,
        cls: "kw-page-choose-template kw-page-choose-template-desc kw-dt-create-wizard"
    };
 
    Ext.apply(card2Config, fieldSetConfig_Card2);
    this._card2 = new Ext.form.FieldSet(card2Config);

    Ext.applyIf(config, {
        title: kw.Strings.Dialog.DatatableCreate.title,
        height: 580,
		width: 659,
		minWidth: 659,
        autoFocus: true,
        cards: [this._card1, this._card2],
        finishButtonText: kw.Strings.Dialog.DatatableCreate.btnCreateDt
    });

	kw.Dialog.DatatableCreate.superclass.constructor.call(this,config);
};

// extend
Ext.extend(kw.Dialog.DatatableCreate, kw.Dialog.WizardBase, {

	helpid: "cs_add_data_table",
    r_object_type: "dmc_room",

    initialize:function()
    {
        var _initcomplete=function(dataStore, records, options)
        {
            if (!records.length) {
                kw.ActionLib.displayError(kw.Strings.Dialog.DatatableCreate.noDtTemplateError);
//                Ext.Msg.alert(kw.Strings.Error.error, kw.Strings.Dialog.DatatableCreate.noDtTemplateError);
                return;
            }

            var myData = [];
            var map = {};

            for (var i = 0, len = records.length; i < len; i++)
            {
                var template_category = records[i].data["a_template_category"];
                if (template_category)
                    template_category = template_category.trim();
                if (!Ext.isEmpty(template_category)) {
                    if (!map[template_category])
                    {
                        map[template_category]=true;
                        myData.push([template_category, Ext.util.Format.ellipsis(template_category,23)]);
                    }
                }
            }

            myData.sort(kw.Util.caseInsentiveSort);
            myData.unshift([kw.Strings.Dialog.DatatableCreate.all, kw.Strings.Dialog.DatatableCreate.all]);
            this.categoriesStore.loadData(myData);
            kw.Dialog.DatatableCreate.superclass.initialize.call(this);

            if (this.categoriesView.store.data.length > 0)
            {
                // select the ALL categories
                this.categoriesView.select(0);
            }
             if (this.templatesView.store.data.length > 0)
            {
                this.templatesView.select(0);
             }
        };  // end handler
        var filter = new FilterInfo()
            filter.parameters = [{
                name: "space_name",
                value: this.context.getSpaceContext().getSpaceProperties().get("object_name")//TODO ask dlm for best way to do this   // dlm actionArgs.context.space
            }];
        var storeLoadParams = {serviceMethodParams : new Object({
                                        listQuery: {datalistId: "active_datatable_templates",
                                        repositories: [this.context.repository]},
                                    filter:filter, sorting:null})};

        this.templatesStore.on("load",_initcomplete,this);
        this.templatesStore.load({params:storeLoadParams});

    },

    onTemplateSelectorContainerClick : function(dv, e) {
        return false;
    },

    onTemplateSelectorBeforeClick: function(dv, index, node, e) {
        if (index == dv.getSelectedIndexes()[0])
            return false;
        return true;
    },

    onTemplateChange: function(dataview, selections) {
        var records = dataview.getRecords(selections);
        if (records.length == 1) {
            var record = records[0];
        }
    },

    submit:function(){

        var formContents = this._formpanel.getForm().getValues();

        var selNode = this.templatesView.getSelectedNodes();
        if (selNode.length == 0)
        {
            return;
        }
        this.progressDialogTitle = kw.Strings.Dialog.DatatableCreate.title;
        var msg = String.format(kw.Strings.Dialog.DatatableCreate.creatingDt, formContents.object_name);
        kw.Progress.ShowProgress(this,msg,this.progressDialogTitle);
        this.createDT(formContents);
    },
    createDT: function(formContents) {

        var ctx = this.actionArgs.context;

        var selNode = this.templatesView.getSelectedNodes();
        var templateId = new ObjectIdentity();
        templateId.value = selNode[0].id;
        templateId.valueType = "OBJECT_ID";
        templateId.repositoryName = ctx.repository;

        var objectLocation = new ObjectLocation();

        if (typeof this.actionArgs.locationId != 'undefined')
        {
            objectLocation.objectIdentity = this.actionArgs.locationId;    // Use user selected location if there is one.
        }else{
            var meta;
            if (kw.Util.hasSelection(this.actionArgs)){
                meta = this.actionArgs.selection.items[0].metadata;
            }else{
                meta = this.context.getContextProperties();
            }
            objectLocation.objectIdentity = new ObjectIdentity();
            objectLocation.objectIdentity.repositoryName = ctx.repository;
            objectLocation.objectIdentity.valueType = "OBJECT_ID";
            objectLocation.objectIdentity.value = meta.get("r_object_id");
        }

        var props = new PropertySet();
        props.object_name = formContents.object_name.trim();
        props.folder_description = formContents.description;
        
        var templateLocation = Ext.DomQuery.selectNode('input[name=template_location]', selNode[0]).defaultValue;
        if (templateLocation.indexOf("/System/Applications/") != -1)
            this.viewMode = true;
        else
            this.viewMode = false;

        function _createcomplete(data) {
            this.handleResults(data.operationStatusSet, true /* throw summary error*/);

            // fire event
            var actionArgs=new kw.ActionArgs({
                context: this.context,   // context of where this happened
                metadata: {
//dlm wrong type; don't bother                    r_object_type: meta.get('r_object_type'),
                    r_object_id: data.operationStatusSet[0].objectId.value,
                    r_parent_id: objectLocation.objectIdentity.value
            }
            });
            kw.Events.publish(kw.EventNames.ItemCreated, actionArgs);

            var context=this.context.getContext(actionArgs.metadata);
            context.view = "content";
            var newActionArgs = new kw.ActionArgs({context: context});
            if(this.viewMode){
                delete this._progress;   // keep close() from removing progress
                kw.DatatableLib.EditSchema(newActionArgs);
            }
            else{

                function localSuccess(result){
                    kw.RendEng.navigate(context);
                }

                function localFailure(result){
                    var body = kw.buildDialogBody(kw.Strings.Error.errorOccured, Ext.util.Format.htmlEncode(kw.Strings.Datatable.Lifecycle.lifecyclesNotFound));
                    var el = this.el;
                    kw.MessageBox.show({
                        msg:     body,
                        buttons: {ok: kw.Strings.btnClose},
                        icon:    Ext.MessageBox.ERROR,
                        cls:     'kw-msg-alert',
                        fn: function() {
                             kw.DatatableLib.EditSchema(newActionArgs);
                        }
                    }, null);

                }

                var filter = new FilterInfo();
                filter.parameters = [{ name: "datatable_id", value: newActionArgs.context.id },
                                          { name:"space_id", value: newActionArgs.context.getSpaceId()}];

                var queryParameters = new PropertySet();
                var listQuery = new ListQuery().init('datatable_query', actionArgs.context.repository, queryParameters);
                queryParameters.space_id = actionArgs.context.getSpaceId();
                queryParameters.datatable_id = newActionArgs.context.id;

                ListService.fetchMetadata(listQuery, filter,
                                             kw.getCallbackClosure(this, localSuccess, localFailure));
            }

            this.close();
        };
        
        var callback = kw.getCallbackClosure(this, _createcomplete);
        TemplateService.instantiateTemplate(templateId, objectLocation, props, callback);
    }
});  // end extend



// DatatableExport.js

/*
 * Copyright (c) 2010 EMC Corporation. All Rights Reserved.
 */

kw.ScriptLoader.require("js/kw/Dialog/DialogBase.js");
kw.ScriptLoader.require("js/kw/widget/Literal.js");
kw.ScriptLoader.require("js/kw/widget/form/LiteralField.js");

Ext.namespace('kw.Dialog');

kw.Dialog.DatatableExport = function(config)
{
    kw.ScriptLoader.requireStrings("DatatableExport");

    if (typeof config == "undefined") config = {};
    this.establishContext(config);

    // Check if we have query Id & get entries count.
    this.searchQueryId = null;
    if (config.actionArgs.component)
    {
        var gridComp = kw.widget.PageControl.findPageAreaByClass(config.actionArgs.component,
                "kw-dt-grid-component", true);
        if (gridComp)
        {
            var queryId = gridComp._dataStore.getResultsCacheQueryId();
            if (queryId.indexOf("queryId-") == 0)
            {
                this.searchQueryId = queryId;
                this.numEntries = gridComp._dataStore.totalFilterMatches;
            }
            else
                this.numEntries = gridComp._dataStore.totalLength;
        }
    }

    Ext.applyIf(config, {
        title: kw.Strings.Dialog.DatatableExport.title,
        height: 365,
		width: 500,
		minWidth: 500,
        buttons: [{text: kw.Strings.Dialog.DatatableExport.buttonExport, handler:this.submit, scope:this},
                  {text: kw.Strings.btnCancel, handler: this.cancel, scope:this}]
    });

	kw.Dialog.DatatableExport.superclass.constructor.call(this,config);
};

// extend
Ext.extend(kw.Dialog.DatatableExport, kw.Dialog.DialogBase, {

	helpid: "cs_export_data_table_entries",

    initialize: function()
    {
        var hasRichText = false;
        var mappingFields = "";
                    
        if (this.context.getFields)
        {
            if (!kw.widget.PageControl.datatableWidgetList){
                var actionArgs = new kw.ActionArgs({context: this.actionArgs.context, component: this.actionArgs.component});
                var widgetCategories = [];
                widgetCategories.push("datatable");
                widgetCategories.push("field");
                kw.widget.PageControl.datatableWidgetList = kw.widget.PageControl.loadWidgetList(actionArgs, widgetCategories);
            }
            
            var metrics = Ext.util.TextMetrics.createInstance(document.body);
            var fieldTpl = "<div class='kw-dt-import-column-field'><div class='kw-dt-import-column-name'>{0}</div><div>{1}</div></div>"

            var fields = this.context.getFields();
            for (var i = 0; i < fields.length; i++)
            {
                var field = fields[i];
                var fieldType;

                // Shortcut: Instead of calling service to get data table fields, here we look for fields whose
                // names start with "column_" since data table field names always start with "column_".
                if (field.columnName.indexOf("column_") == 0)
                {
                    var widgetsLen = kw.widget.PageControl.datatableWidgetList.length;
                    for (var j = 0; j < widgetsLen; j++)
                    {
                        if (kw.widget.PageControl.datatableWidgetList[j][4]/*rcmp_sid*/ == field.renderType)
                        {
                            fieldType = kw.widget.PageControl.datatableWidgetList[j][2];
                            break;
                        }
                    }

                    var colName = kw.Util.ellipsisByPixelWidth(metrics, field.columnLabel, 225, '...');
                    mappingFields += String.format(fieldTpl, colName, "(" + fieldType + ")");
                }
                
                if (!hasRichText && (field.renderType == "cma.kw.form.RichText"))
                {
                    hasRichText = true;
                }
            }
        }

        this.mappingFields =new Ext.Component({html: "<div class='kw-dt-import-mapping-fields'>" +
                                                     mappingFields + "<div>"});
        
        this.useHTML = new Ext.form.Checkbox({
            name: "useHTML", hiddenName: "useHTML", fieldLabel: "", hideLabel:true, labelSeparator:"",  checked: hasRichText,
            boxLabel: kw.Strings.Dialog.DatatableExport.userHtml, hidden: !hasRichText});

        var quotedName = "\"" + this.context.getContextProperties().get("object_name") + "\"";
        var numEntryExported = "";
        if (this.numEntries == 1)
            numEntryExported = String.format(kw.Strings.Dialog.DatatableExport.numEntryExported, this.numEntries)
        else if ((this.numEntries == 0) || (this.numEntries > 1)){

            if (this.numEntries == 150 && this.searchQueryId)
                numEntryExported = kw.Strings.Dialog.DatatableExport.filterCriteriaMsg;
            else
                numEntryExported = String.format(kw.Strings.Dialog.DatatableExport.numEntriesExported, this.numEntries)
        }
        
        this._formpanel = new kw.Dialog.FormPanel({
            items: [
                new kw.widget.form.LiteralField({hideLabel:true, labelSeparator: "",
                    value: quotedName , cls: "kw-dt-import-file-name"}),
                {xtype: "literalfield", hideLabel:true, labelSeparator: "",
                    value: kw.Strings.Dialog.DatatableExport.fieldsMapping, cls: "kw-form-text"},
                this.mappingFields,
                new kw.widget.form.LiteralField({hideLabel:true, labelSeparator: "", cls: "kw-form-text",
                    value: numEntryExported, hidden: (numEntryExported.length == 0)}),
                this.useHTML
            ]
        });
        this.add(this._formpanel);
        this.doLayout();

        kw.Dialog.DatatableExport.superclass.initialize.call(this);
    },

    submit:function()
    {
        this.hide();

        var params = "";
        if (this.useHTML.getValue())
            params = "?ishtml=true";

        if (this.searchQueryId)
        {
            params += (params.length == 0) ? "?" : "&";
            params += "queryid=" + this.searchQueryId;
        }

        var iframes = kw.Util.createIFrames([this.context.id]);
        var template = '/{0}/datatable-export/{1}/{2}{3}';
        var content_url = String.format(template, kw.getAppName(), this.context.repository, this.context.id, params);

        var iframe = iframes[0];
        iframe.src = content_url;
        iframe=null;

        this.close();
    }
});  // end extend
/* DataTableGridComponent.js */

(function() {

kw.ScriptLoader.require("js/kw/ItemViewComponent.js");
kw.ScriptLoader.require("js/kw/widget/form/MemberField.js");
rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/DataTableColumnModel.js");
rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/DtSearchServiceResultsReader.js");
rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/RowControl.js");

kw.ScriptLoader.requireStrings("Datatable");

/**
 * The view for SummaryGrid widget.
 */
kw.widget.DataTableGridComponent = function(config) {
    config.serviceMethod = ListService.fetchResults;
    config.serviceMethodParams = {
        listQuery: {
            datalistId: "datatable_query",
            repositories: [config.context.repository],
            context:kw.Util.getListQueryContainerContext(config.tableId)
        },
        filter:null, sorting:null};

    if (Ext.isEmpty(config.tableId)) {
        this.loadOnConstruction = false;
        this.failToLoadMsg = kw.Strings.Error.notConfigured;
        this.bNotConfigured = true;
    }
    else {
        kw.widget.establishContextId(this, config.tableId, config);

        config.filterParameters = [{name: "datatable_id", value: config.tableId},
            {name:"space_id", value: config.context.getSpaceId()}];

        var repo = kw.getContext().repository;
        var tableIdentity = new ObjectIdentity();
        tableIdentity.repositoryName = repo;
        tableIdentity.value = config.tableId;
        tableIdentity.valueType = "OBJECT_ID";
        
        config.userPrefSettings = {
            objIdentity:tableIdentity,
            viewPrefName: "ViewMode",
            hiddenColumnsPrefName: "HiddenColumns",
            columnsWidthPrefName: "ColumnsWidth",
            orderedColumnsPrefName: "OrderedColumns",
            filterPrefName: "Filters",
            sortFieldPrefName:"DataTableSortField",
            sortOrderPrefName:"DataTableSortOrder"
        };
    }

    Ext.applyIf(config, {
        datalistId: config.tableId,
        loadOnConstruction: this.loadOnConstruction,
        failToLoadMsg: this.failToLoadMsg
    });

    var defaultConfig = {
        isWidget: true,
        toolbarName: "datatablegrid.toolbar",
        selectioncontextmenu: "datatablegrid.selection.contextmenu",
        backgroundcontextmenu: "datatablegrid.background.contextmenu",
        gridEventHandlers: kw.widget.GridEventHandlers.ItemListEventHandlers,
        iconView: false,
        imageFlowView: false,
        enableDrop: true,
        columnModel: kw.widget.datatable.DataTableColumnModel,
        enablePreview: false,
        defaultSort: {field: "r_creation_date", order: "ASC"}
    };

    Ext.applyIf(config, defaultConfig);
    kw.widget.DataTableGridComponent.superclass.constructor.call(this, config);
    this.addClass("kw-dt-grid-component")
    rcmp.intf.attachInterfaces(this, kw.widget.DataTableGridComponent);

    this._grid.getView().on("rowsRendered", this.onRowsRendered, this);

    var exprSetFilters = this.getSearchFilters();
    if (exprSetFilters)
        this.setupForSearchService(exprSetFilters, false);

    // When navigate from summary page to an entry page,
    // hand off of a store from a summary grid to the entry page.
    // Ownership of the store passes from the grid to the entry page,
    // and the lifetime of the store is then tied to the lifetime of the entry page.
    this._grid.preNavigate = function(rowContext) {rowContext.navData = {store: this.getStore()};};
};

Ext.extend(kw.widget.DataTableGridComponent, kw.ItemViewComponent, {
    initEvents: function() {
        kw.widget.DataTableGridComponent.superclass.initEvents.call(this);

        var pc = kw.widget.PageControl.getPageControlForWidget(this);
        if (pc) {
            pc.registerProvider("kw.component.IDataTableGrid", this);

            // Data table summary page isn't an editable page.
            // Return false for the pageeditmode event when the summary grid
            // is on the data table summary page.
            if (pc.context.getContextProperties().get("r_object_type") == "dmc_datatable") {
                pc.on("pageeditmode", function() {return false;}, this);
            }
        }

        function onHiddenChange() {
            this._grid.colModel.calculateTotalDefaultWidth();
            this._grid.view.fitColumns();
        }
        this._grid.colModel.on("hiddenchange", onHiddenChange, this);
    },

    onRender: function() {
        kw.widget.DataTableGridComponent.superclass.onRender.apply(this, arguments);
        var store = this.getStore();
        var thisTab = kw.RendEng.getTabManager().findTabComponentForNode(this.el.dom);
        store.tab = thisTab;

        thisTab.on("dtentrytreenav", this.onTreeNavToEntry, store);

         if (thisTab.events.dtentrytreenav.listeners.length > 1)
            kw.Util.debugHere("too many listeners");

        store.on("beforedestroy", function() {
            thisTab.un("dtentrytreenav", kw.widget.DataTableGridComponent.prototype.onTreeNavToEntry, store);
        });

        this.on("beforedestroy", function() {
            if (thisTab.fullContext) {
                if (!thisTab.fullContext.navData || (thisTab.fullContext.navData.store !== store)) {
                    thisTab.un("dtentrytreenav", kw.widget.DataTableGridComponent.prototype.onTreeNavToEntry, store);
                }
            }
        }, this);
    },

    // This is called when user clicks on DT entry in nav tree. ***NOTE***: this === store
    onTreeNavToEntry: function(entryId, entryIndex, parentId) {
        var store = this;
        var index = store.find("r_object_id", entryId);
        var rowControl = kw.widget.datatable.getRowControl(store.tab.el.dom);
        var newContext = new kw.Context(this.context);
        newContext.view = 'content';
        newContext.tab = null;
        newContext.pgview = null;
        newContext.queryString = null;
        newContext.navData = {store: this};
        newContext.id = entryId;
        if (index != -1) {
            if (rowControl && rowControl.dtStore) {
                rowControl.updateForNextPrevious(index);
            }
            else {
                kw.RendEng.navigate(newContext);
            }
            return true;
        }
        else if (rowControl && (entryIndex >= 0) && (this.context.id == parentId))
            return rowControl.updateEntryByIndex(entryIndex);

        else if (!rowControl && (entryIndex >= 0) && (store.proxy.func === ListService.fetchResults)) {
            if (this.context.id != parentId)
                return false;
            var execOptions = store.lastOptions.params.serviceMethodParams.filter.execOptions;
            var pageSize = execOptions.maxResultCount;
            execOptions.startingIndex = Math.floor(entryIndex/pageSize) * pageSize;

            store.on("load", function() {
                var execOptions = this.lastOptions.params.serviceMethodParams.filter.execOptions;

                Ext.apply(kw.PagingToolbar.savedGridPageNumber, {
                    url: this.context.getUrl(),
                    objectId: this.context.id,
                    datalistId: this.queryId,
                    page: execOptions.startingIndex/execOptions.maxResultCount + 1,
                    timestamp: new Date()
                });
                newContext.navData = {store: store};
                kw.RendEng.navigate(newContext);
            }, store, {single: true});

            store.reload();
            return true;
        }
        else
            return false;
    },

    getGridViewConfig: function()  {
        var config = kw.widget.DataTableGridComponent.superclass.getGridViewConfig.apply(this, arguments);
        config.xtype = "kwdtgrid";
        return config;
    },

    setupForListService : function(bReloadStore) {
        this._dataStore.proxy.func = ListService.fetchResults;
        this._dataStore.reader = new kw.widget.datatable.Reader();
        delete this._dataStore.totalFilterMatches;
        delete this._dataStore.totalEntries;

        this._storeLoadParams = {start:0, limit:this.config.pageSize};

        var filter = new FilterInfo();
        filter.parameters = [{ name: "datatable_id", value: this.config.tableId },
            { name:"space_id", value: this.config.context.getSpaceId()}];

        filter.execOptions = new QueryExecution();
        Ext.apply(filter.execOptions, {startingIndex:0, maxResultCount:this.config.pageSize});

        this._storeLoadParams.serviceMethodParams = {
            listQuery: {
                datalistId: "datatable_query",
                repositories: [this.config.context.repository],
                context:kw.Util.getListQueryContainerContext(this.config.tableId)
            },
            filter:filter, sorting:null};

        if (bReloadStore) {
            this._dataStore.reload({params:this._storeLoadParams});

            var prefSettings = this.config.userPrefSettings;
            var prefNameValuePairs = new Object();
            prefNameValuePairs[prefSettings.filterPrefName] = "";
            kw.Util.savePreferences(prefSettings, prefNameValuePairs);

            kw.Events.publish(kw.EventNames.DtNoSearchFilter, {
                 datatableId: this.config.tableId
             });

            kw.Events.publish(kw.EventNames.DtSearchFilterPrint, {
                 searchFilterStrExp: this.getSearchFilterExpStr()
             });

        }
    },

    setupForSearchService : function(exprSetFilters, bReloadStore) {
        if (!exprSetFilters || exprSetFilters.length == 0) {
            this.setupForListService(bReloadStore);
            return;
        }
        
        this._dataStore.proxy.func = SearchService.search;
        this._dataStore.reader = new kw.data.DtSearchServiceResultsReader();

        this._storeLoadParams = {start:0, limit:this.config.pageSize};
        
        var filter = new FilterInfo();
        filter.parameters = [{name: "datatable_id", value: this.config.tableId},
            {name:"space_id", value: this.config.context.getSpaceId()}];
        filter.execOptions = new QueryExecution();
        Ext.apply(filter.execOptions, {startingIndex:0, maxResultCount:this.config.pageSize, maxResultPerSource: 150});

        var rowTypeName = this.context.getContextProperties().get("_kw_row_type_name");

        var query = new UserQuery();
        var repository = this.context.repository;
        query.metaDataRepository = repository;
        query.repositories = [repository];
        query.objectType = rowTypeName;
        query.exprSetFilters = exprSetFilters;        

        this._storeLoadParams.serviceMethodParams = new Object({datalistId: "datatable_search",
            query: query,
            filter:filter,
            sorting:null});

        if (bReloadStore) {
            this._dataStore.reload({params:this._storeLoadParams});

            var prefSettings = this.config.userPrefSettings;
            var prefNameValuePairs = new Object();
            prefNameValuePairs[prefSettings.filterPrefName] = Ext.util.JSON.encode(exprSetFilters);
            kw.Util.savePreferences(prefSettings, prefNameValuePairs);
        }
    },

    getSearchFilters : function() {
        var exprSetFilters;
        
        var prefSettings = this.config.userPrefSettings;
        if (prefSettings) {
            kw.Util.getPreferences(prefSettings);
            var filterEncodeStr = prefSettings.preferences[prefSettings.filterPrefName];
            if (filterEncodeStr)
                exprSetFilters = Ext.util.JSON.decode(filterEncodeStr);
        }

        this.removeObsoleteSearchFilters(exprSetFilters);
        
        return exprSetFilters;
    },

    getSearchFilterExpStr: function() {
        var colFilters = this.getColumnFilters();
        if(!colFilters.length > 0)
        {
            return this.getFullTextFilterVal();
        }

        var generateSearchFilterExpStr = function(columnFilters, filterExpString) {
            for (var y=0; y<columnFilters.length; y++) {
                if (columnFilters[y].expressions)
                    return generateSearchFilterExpStr(columnFilters[y].expressions, filterExpString);
                else {
                    var columDef = this.getColumnDef(columnFilters[y].property);
                    if (!columDef) {
                        /* When specify the due date status search expression, we use the
                           date column id appended with "_is_done" as the PropertyExpression.property value.
                           However, when we try to find the column or column definition by id,
                           the id should be the date column id, not the one appended with "_is_done".
                         */
                        var dateColumnId = this.getDateColumnId(columnFilters[y].property);
                        columDef = this.getColumnDef(dateColumnId);
                    }
                    var label= columDef.columnLabel;
                    filterExpString = " "+filterExpString + label +" "
                    switch(columnFilters[y].condition)
                    {
                        case "EQUAL":
                        {
                            filterExpString = filterExpString + kw.Strings.Action.Pro.Datatable.Filter._equal +" "+
                                                 columnFilters[y].value.value;
                            break;
                        }
                        case "GREATER_THAN":
                        {
                            filterExpString = filterExpString + kw.Strings.Action.Pro.Datatable.Filter._greaterThan+" "+
                                                 columnFilters[y].value.value;
                            break;
                        }
                        case "LESS_THAN":
                        {
                            filterExpString = filterExpString + kw.Strings.Action.Pro.Datatable.Filter._lessThan+" "+
                                                 columnFilters[y].value.value;
                            break;
                        }
                        case "GREATER_EQUAL":
                        {
                            filterExpString = filterExpString + kw.Strings.Action.Pro.Datatable.Filter._greaterEqual+" "+
                                                 columnFilters[y].value.value;
                            break;
                        }
                        case "LESS_EQUAL":
                        {
                            filterExpString = filterExpString + kw.Strings.Action.Pro.Datatable.Filter._lessEqual+" "+
                                                 columnFilters[y].value.value;
                            break;
                        }
                        case "NOT_EQUAL":
                        {
                            filterExpString = filterExpString + kw.Strings.Action.Pro.Datatable.Filter._notEqual+" "+
                                                 columnFilters[y].value.value;
                            break;
                        }
                        case "BETWEEN":
                        {
                            filterExpString = filterExpString + kw.Strings.Action.Pro.Datatable.Filter._between+" "+
                                                 columnFilters[y].value.fromValue+ " "+
                                                kw.Strings.Action.Pro.Datatable.Filter._and+" "+
                                                columnFilters[y].value.toValue;
                            break;
                        }
                        case "CONTAINS":
                        {
                            filterExpString = filterExpString + kw.Strings.Action.Pro.Datatable.Filter._contains +" "+
                                                 columnFilters[y].value.value;
                            break;
                        }
                        case "IN":
                        {
                            filterExpString = filterExpString + kw.Strings.Action.Pro.Datatable.Filter._in +" "+
                                                 columnFilters[y].value.values.join(',');
                        }
                        case "IS_NULL":
                        {
                            filterExpString = filterExpString + kw.Strings.Action.Pro.Datatable.Filter._blank;
                            break;
                        }
                        case "IS_NOT_NULL":
                        {
                            filterExpString = filterExpString + kw.Strings.Action.Pro.Datatable.Filter._notblank;
                            break;
                        }
                        default:
                        {
                            filterExpString = filterExpString + kw.Strings.Action.Pro.Datatable.Filter._equal +" "+
                                                 columnFilters[y].value.value;
                            break;
                        }

                    }
                    if(y < columnFilters.length-1)
                        filterExpString = filterExpString + kw.Strings.Action.Pro.Datatable.Filter._separator + " "+
                                kw.Strings.Action.Pro.Datatable.Filter._and+" ";
                }
            }
            return filterExpString;
        }.createDelegate(this);
        return generateSearchFilterExpStr(colFilters, "");
    },

    /* When specify the due date status search expression, we use the
       date column id appended with "_is_done" as the PropertyExpression.property value.
       However, when we try to find the column or column definition by id,
       the id should be the date column id, not the one appended with "_is_done".
       This helper function is used to get the date column id from the due date id.
     */
    getDateColumnId : function(dueDateColumnId) {
        var isDoneStr = "_is_done";
        var isDoneStrLen = isDoneStr.length;
        var isDoneStrStartIndex = dueDateColumnId.length - isDoneStrLen;
        if (dueDateColumnId.substr(isDoneStrStartIndex) == isDoneStr)
            return dueDateColumnId.substring(0, isDoneStrStartIndex);            
        return null;
    },    

    removeObsoleteSearchFilters : function(exprSetFilters) {
        if (!exprSetFilters) 
            return;

        var findObsoleteColumn = function(columnFilterExpressions, obsoleteColumns) {
            for (var y=0; y<columnFilterExpressions.length; y++) {
                if (columnFilterExpressions[y].expressions)
                    findObsoleteColumn(columnFilterExpressions[y].expressions, obsoleteColumns);
                else {
                    var columnId = columnFilterExpressions[y].property;
                    if (searchableColumns.indexOf(columnId) == -1 && obsoleteColumns.indexOf(columnId) == -1 ) {
                        /* When specify the due date status search expression, we use the
                           date column id appended with "_is_done" as the PropertyExpression.property value.
                           However, when we try to find the column or column definition by id,
                           the id should be the date column id, not the one appended with "_is_done".
                         */
                        var dateColumnId = this.getDateColumnId(columnId);
                        if (!dateColumnId)
                            obsoleteColumns.push(columnId);
                        else if (searchableColumns.indexOf(dateColumnId) == -1)
                            obsoleteColumns.push(columnId);
                    }
                }
            }
        }.createDelegate(this);

        var removeObsoleteColumn = function(columnFilterExpressions, columnId) {
           for (var z=columnFilterExpressions.length-1; z>=0; z--) {
                if (columnFilterExpressions[z].expressions) {
                    removeObsoleteColumn(columnFilterExpressions[z].expressions, columnId);
                    if (columnFilterExpressions[z].expressions.length == 0)
                        columnFilterExpressions.splice(z, 1);    
                }
                else {
                    if (columnId == columnFilterExpressions[z].property) {
                        columnFilterExpressions.splice(z, 1);
                    }
                }
            }
        }

        for (var i=0; i<exprSetFilters.length; i++) {
            if (exprSetFilters[i].filterId == "column") {
                var meta = this.context.getContextProperties();
                var searchableColumns = kw.Util.deepClone(meta.get("_kw_summary_settings").searchableColumns);
                searchableColumns.unshift("r_modify_date");
                searchableColumns.unshift("r_modifier");
                
                var columnFilterExpressions = exprSetFilters[i].expressionSet.expressions;
                var obsoleteColumns = new Array();
                findObsoleteColumn(columnFilterExpressions, obsoleteColumns);

                for (var y=0; y<obsoleteColumns.length; y++) {
                    var columnId = obsoleteColumns[y];
                    removeObsoleteColumn(columnFilterExpressions, columnId);
                }

                if (columnFilterExpressions.length == 0)
                    exprSetFilters.splice(i, 1);

                if (obsoleteColumns.length != 0) {
                    var prefSettings = this.config.userPrefSettings;
                    var prefNameValuePairs = new Object();
                    var exprSetFiltersStr = "";
                    if (exprSetFilters.length != 0)
                        exprSetFiltersStr =  Ext.util.JSON.encode(exprSetFilters);
                    prefNameValuePairs[prefSettings.filterPrefName] = exprSetFiltersStr;
                    kw.Util.savePreferences(prefSettings, prefNameValuePairs);                    
                }
            }
        }
    },

    getColumnDef : function(columnId) {
        var columnInfo = this.context.getFields();
        var columnDef;
        for (var i=0; i<columnInfo.length; i++) {
            if (columnInfo[i].columnName == columnId) {
                return columnInfo[i];
            }
        }
        return null;
    },

    getFullTextFilterVal : function() {
        var exprSetFilters = this.getSearchFilters();
        if (exprSetFilters) {
            for (var i=0, len=exprSetFilters.length; i<len; i++) {
                if (exprSetFilters[i].filterId == "fulltext") {
                    return exprSetFilters[i].expressionSet.expressions[0].value;
                }
            }
        }
        return null;
    },

    getColumnFilters : function() {
        var columnFilterExpressions = [];
        var exprSetFilters = this.getSearchFilters();
        if (exprSetFilters) {
            for (var i=0, len=exprSetFilters.length; i<len; i++) {
                if (exprSetFilters[i].filterId == "column") {
                    columnFilterExpressions = exprSetFilters[i].expressionSet.expressions;
                    break;
                }
            }
        }
        return columnFilterExpressions;
    },

    isAdvFiltersInEffect : function(exprSetFilters) {
        if (!exprSetFilters)
            exprSetFilters = this.getSearchFilters();
        
        if (exprSetFilters) {
            for (var i=0, len=exprSetFilters.length; i<len; i++) {
                if (exprSetFilters[i].filterId != "fulltext") {
                    return true;
                    break;
                }
            }
        }
        return false;
    },

    createDataStore: function() {
        var key = this.context.id;


        if (this.config.store) return this.config.store;
        var store = new kw.data.Store({
	        proxy:   new kw.data.DWRProxy(this.config.serviceMethod, this),
	        reader:  new kw.widget.datatable.Reader(),
	        queryId: this.config.datalistId,
	        remoteSort: true,
            context: this.context,
			userPrefSettings: this.config.userPrefSettings,
            defaultSort: this.config.defaultSort
	    });

        var props = this.context.getContextProperties();
        kw.data.DtMetadataCache.updateCache(key, {
            schema_id: props.get("schema_id"),
            object_name: props.get("object_name")
        });

        return store;
    },

    _loadData: function() {
        if (this._dataStore.data.items && this._dataStore.data.items && this._dataStore.data.items.length) {
            this.un("afterlayout", this._loadData, this);
            this._grid.view.onLoad();
        }
        else
            kw.widget.DataTableGridComponent.superclass._loadData.apply(this, arguments);
    },

/*
    onAfterReadCallback: function(records)
    {
        if (this._grid && this._grid.metadata && this._grid.metadata.columnDefinition && records)
        {
            var columnDefinition = this._grid.metadata.columnDefinition;

            //  Preprocess cell values here before rendering
            if (records.totalRecords > 0)
            {
                records = records.records;
                sortMemberListColumnNameValues.call(this, records, columnDefinition);
            }
        }
    },
*/

    onRowsRendered: function() {
        var pageControl = kw.widget.PageControl.getPageControlForWidget(this);
        if (pageControl) {
            var context = pageControl.context;
            if (context.getContextProperties().getMetaType() == kw.MetaType.ROW) {
                var rowObjId = context.id;
                this.selectRow(rowObjId);
            }
        }
    },

    preNavigate: function(rowContext) {
        // When navigate from summary page to an entry page,
        // hand off of a store from a summary grid to the entry page.
        // Ownership of the store passes from the grid to the entry page,
        // and the lifetime of the store is then tied to the lifetime of the entry page.
        this._grid.preNavigate(rowContext);            
    },
    
    /// kw.component.IWidget ///
    getTitle: function() {
        if (this.initialConfig.title == kw.Strings.WidgetNoTitleBar)
            return "";

        if (this.initialConfig.title)
            return Ext.util.Format.htmlEncode(this.initialConfig.title);
        else
            return "";   //kwc-6999
    },
    onSelect: function() {
        if (this.bNotConfigured || this.bContentUnavailable)
            return;

        this.displayWidgetToolbar();
    },
    onDeselect: function() {},
    onPageEdit: function() {},
    onPageSave: function() {},
    onPageEditCancel: function() {},
    onRemoveWidget: function() {},
    canUpdateSelf: function() { return false; },
    onUpdate: function() {},
    /// end kw.component.IWidget ///

    // kw.component.IDataTableGrid
    onStoreEvent: function(evt, fn, scope, args, bRemove)  {
        if (bRemove) {
            this._dataStore.un(evt, fn, scope);
        }
        else {
            this._dataStore.on(evt, fn, scope, args);
        }
    },
    onGridEvent: function(evt, fn, scope, args, bRemove)  {
        var target = this._grid;
        if ((evt == "rowselect") || (evt == "selectionchange"))
            target = this._grid. getSelectionModel();
        if (bRemove) {
            target.un(evt, fn, scope);
        }
        else {
            target.on(evt, fn, scope, args);
        }
    },
    selectRow: function(arg) {
        if ((typeof arg == "object") && arg.id) {
            return this.selectRow(arg.id)
        } else if (typeof arg == "string") {
            var store = this._grid.store;
            var n = store.getCount();
            for (var i=0; i < n; ++i) {
                var rec = store.getAt(i);
                if ((rec._dt_objectIdentity.valueType == "OBJECT_ID") && (rec._dt_objectIdentity.value == arg)) {
                    this._grid.getSelectionModel().selectRow(i, false);
                    this._grid.getView().focusRow(i);
                    return true;
                }
            }
        }

        return false;
    },

    getColumnTitle: function(dataIndex) {
        var col = this._grid.getColumnModel(). getColumnById(dataIndex);
if (!col) kw.Util.debugHere("col not found");
        return col.header;
    }
    // end kw.component.IDataTableGrid

});

kw.widget.datatable.Grid = function(config) {
    kw.widget.datatable.Grid.superclass.constructor.apply(this, arguments);
};
Ext.extend(kw.widget.datatable.Grid, kw.widget.Grid, {
    onResize: function() {
        kw.widget.datatable.Grid.superclass.onResize.apply(this, arguments);
        if(this.viewReady){
            this.view.layout();
      }
    },
    getGridView: function() {
        return new kw.widget.datatable.GridView({forceFit:true, rowIsTabStop: this.config.rowIsTabStop});
    }
});
Ext.reg("kwdtgrid", kw.widget.datatable.Grid);

kw.widget.datatable.GridView = function(config) {
    config.rowSelectorDepth = 0;//KWC-17850
    kw.widget.datatable.GridView.superclass.constructor.apply(this, arguments);
};
Ext.extend(kw.widget.datatable.GridView, kw.widget.GridView, {
    fitColumns: function(preventRefresh, onlyExpand, omitColumn) {

        var cm = this.cm, i;
        var tw = cm.totalDefaultWidth;

        var inner = this.grid.findParentBy(function(c) {
                    return c.el.hasClass("kw-dt-content-area");}
                );
        var outer = inner.ownerCt;
        var aw = outer.getWidth(true)-this.getScrollOffset();
        if (tw > aw) {
            outer.getLayoutTarget().applyStyles({"overflow-x": "auto"});
            inner.setWidth(tw);
            this.grid.ownerCt.setWidth(tw);
            this.grid.setWidth(tw);
            this.gridWidthAdjusted = true;
        }
        else if (this.gridWidthAdjusted) {
            outer.getLayoutTarget().applyStyles({"overflow-x": "hidden"});
            var auto = "auto";
            inner.setWidth(auto);
            this.grid.ownerCt.setWidth(auto);
            this.grid.setWidth(auto);
            this.gridWidthAdjusted = false;
        }

        return kw.widget.datatable.GridView.superclass.fitColumns.call(this, preventRefresh, onlyExpand, omitColumn);
    }
});

kw.widget.datatable.Reader = Ext.extend(kw.data.ServiceResultsReader, {
    read: function(params, results) {
        var retVal = kw.widget.datatable.Reader.superclass.read.apply(this, arguments);
        if (params.datalistId && results.metaData) {
            kw.data.setQueryMetadata(params.datalistId, results.metaData);// kwc-19131
        }
        return retVal;
    }
});

rcmp.intf.implementInterface(kw.widget.DataTableGridComponent, "kw.component.IRowDataSource");
rcmp.intf.implementInterface(kw.widget.DataTableGridComponent, "kw.component.IDataTableGrid");
rcmp.intf.implementInterface(kw.widget.DataTableGridComponent, "kw.component.IWidget");

Ext.namespace("kw.debug");
kw.debug.DatatableGridComponent = function() {eval("debugger");};

})();

// DatatableImport.js

/*
 * Copyright (c) 2009 EMC Corporation. All Rights Reserved.
 */

kw.ScriptLoader.require("js/kw/Dialog/WizardBase.js");
kw.ScriptLoader.require("js/kw/widget/Literal.js");
kw.ScriptLoader.require("js/kw/widget/form/FieldPlugIn.js");
kw.ScriptLoader.require("js/kw/widget/form/LiteralField.js");

Ext.namespace('kw.Dialog');

kw.Dialog.DatatableImport = function(config)
{
    if (typeof config == "undefined") config = {};
    kw.ScriptLoader.requireStrings("DatatableImport");

    this.establishContext(config);

    this.filechooser_ctrl = new Ext.form.FileUploadField(
        {
            buttonText:  kw.Strings.Dialog.DatatableImport.browseButtonText,
            fieldLabel: kw.Strings.Dialog.DatatableImport.chooseFile,
            width: 280,
            name:  "dtimportfile",
            allowBlank: false,
            listeners:
            {
               'fileselected':
                {
                    fn: this.onFileChange,
                    scope: this,
                    single: false
                }
            }
        });

    var card1Config = {
        labelWidth: 150,
        items: [this.filechooser_ctrl]
    };
    this._card1 = new Ext.form.FieldSet(card1Config);

    this.importFileName = new kw.widget.form.LiteralField({
        hideLabel:true, labelSeparator: "", cls: "kw-dt-import-file-name"});
    this.mappingFields = new Ext.Component({html: "<div class='kw-dt-import-mapping-fields'><div>"});
    this.numOfEntries = new kw.widget.form.LiteralField({hideLabel:true, labelSeparator: ""})
    this.useHTML = new Ext.form.Checkbox({
        name: "useHTML", hiddenName: "useHTML", fieldLabel: "", hideLabel:true, labelSeparator:"",  checked: true,
        boxLabel: kw.Strings.Dialog.DatatableImport.useHTML, cls: "x-form-cb-label"});
    var card2Config = {
        items: [
            this.importFileName,
            {xtype: "literalfield", hideLabel:true, labelSeparator: "", value: kw.Strings.Dialog.DatatableImport.mapFields, cls: "kw-form-text"},
            this.mappingFields,
            this.numOfEntries,
            this.useHTML
        ]
    };
    this._card2 = new Ext.form.FieldSet(card2Config);

    Ext.applyIf(config, {
        title: kw.Strings.Dialog.DatatableImport.title,
        height: 425,
		width: 500,
		minWidth: 500,
        autoFocus: true,
        displayStepInfo: true,
        cards: [this._card1, this._card2],
        finishButtonText: kw.Strings.Dialog.DatatableImport.btnImport,
        formCfg: {method: 'POST', fileUpload: true, url: String.format('/{0}/{1}', kw.getAppName(), kw.getTempFileFolderName()),
            //  IE and Safari need this, but FF apparently does not.
            //  In any case, it is apparently never called.
            errorReader: (Ext.isIE || Ext.isSafari || Ext.isChrome || Ext.isGecko) ? new Ext.data.XmlReader({record: "/dummy"}, Ext.data.Record.create([{name: 'dummy'}])) : undefined
        }
    });

	kw.Dialog.DatatableImport.superclass.constructor.call(this,config);
};

// extend
Ext.extend(kw.Dialog.DatatableImport, kw.Dialog.WizardBase, {

	helpid: "cs_import_data_table_entries",

    onFileChange: function() {
        this.fileChanged = true;    
    },

    _onNext: function() {
        if (this.fileChanged) {
            var msg = String.format(kw.Strings.Dialog.DatatableImport.getPreviewMsg,this.filechooser_ctrl.getValue());

            kw.Progress.ShowProgress(this, msg, "");

            var options =
            {
                scope: this,
                success: this.onUploadSuccess,
                failure: this.onUploadFailure,
                clientValidation: false
            };

            this._formpanel.getForm().submit(options);
        }
        else {
            kw.Dialog.DatatableImport.superclass._onNext.call(this);            
        }
    },

    onUploadSuccess: function(form,action)
    {
        var i1;
        var fileUrl = action.response.responseText;
        if (fileUrl.indexOf("<pre>") == 0 || fileUrl.indexOf("<PRE>") == 0)
        {
            i1 = fileUrl.indexOf("</pre>");
            if (i1 == -1)
                i1 = fileUrl.indexOf("</PRE>");
            fileUrl = fileUrl.substring(5,i1);
        }

        i1 = fileUrl.indexOf("file-cache");
        if (i1 != -1)
            fileUrl = fileUrl.substring(i1);

        if (Ext.isChrome)
        {
            i1 = fileUrl.indexOf("</pre>");
            if (i1 == -1)
                i1 = fileUrl.indexOf("</PRE>");
            fileUrl = fileUrl.substring(0,i1);

        }
        
        this.dtObjIdentity = this.actionArgs.context.getObjectIdentity();
        this.fileContent = new FileContent().init(fileUrl, 0);
        var callbacks = kw.getCallbackClosure(this, this.onGetImportPreviewSuccess, this.onGetImportPreviewFailure);
        callbacks.async=false;
        DataTableImportService.getImportPreview(this.dtObjIdentity, this.fileContent, callbacks) 
    },

    onUploadFailure: function(form,action)
    {
        //  this is called only if there was an HTTP transport error
        kw.Progress.EndProgress(this);
        kw.MessageBox.show(
        {
           title: kw.Strings.Dialog.DatatableImport.title,
           buttons: Ext.MessageBox.OK,
           icon: this.errorIcon,
           msg: String.format(kw.Strings.Dialog.DatatableImport.submitFailure, Ext.form.Action.CONNECT_FAILURE)
        });
    },

    onGetImportPreviewSuccess: function(preview) {
        this.initializeWithPreviewInfo(preview);
        kw.Progress.EndProgress(this);
        this.fileChanged = false;        
        kw.Dialog.DatatableImport.superclass._onNext.call(this);
    },

    initializeWithPreviewInfo : function(preview) {
        this.importFileName.setValue('"' + this.filechooser_ctrl.getValue() + '"');

        var mappingFields = "";
        if (!kw.widget.PageControl.datatableWidgetList){
            var actionArgs = new kw.ActionArgs({context: this.actionArgs.context, component: this.actionArgs.component});
            var widgetCategories = [];
            widgetCategories.push("datatable");
            widgetCategories.push("field");
            kw.widget.PageControl.datatableWidgetList = kw.widget.PageControl.loadWidgetList(actionArgs, widgetCategories);
        }
        var fieldTpl = "<div class='kw-dt-import-column-field'><div class='kw-dt-import-column-name'>{0}</div><div>{1}</div></div>"

        var metrics = Ext.util.TextMetrics.createInstance(this.el);

        this.hasRichTextField = false;
        for (var i=0, len=preview.importColumns.length; i<len; i++) {
            var fieldWidgetId = preview.importColumns[i].targetColumn.properties.widgetId;
            if (fieldWidgetId == "cma.kw.form.RichText")
                this.hasRichTextField = true;
            var fieldType = "";
            for (var y=0, len2=kw.widget.PageControl.datatableWidgetList.length; y<len2; y++) {
                if (kw.widget.PageControl.datatableWidgetList[y][4]/*rcmp_sid*/ == fieldWidgetId){
                    fieldType = kw.widget.PageControl.datatableWidgetList[y][2];
                    break;
                }
            }
            var colName = kw.Util.ellipsisByPixelWidth(metrics, preview.importColumns[i].name, 225, '...');
            mappingFields += String.format(fieldTpl, colName, "(" + fieldType + ")");
        }
        this.mappingFields.el.child(".kw-dt-import-mapping-fields", true).innerHTML = mappingFields;

        var entryText = kw.Strings.Dialog.DatatableImport.entry;
        if(preview.entryCount > 1 || preview.entryCount == 0) {
            entryText = kw.Strings.Dialog.DatatableImport.entries;
        }
        
        this.numOfEntries.setValue(String.format(entryText,preview.entryCount));//kwc-17831

        if (this.hasRichTextField)
            this.useHTML.show();
        else
            this.useHTML.hide();
    },

    onGetImportPreviewFailure: function(excName, excObj) {
        kw.Progress.EndProgress(this);
        Ext.Msg.alert(kw.Strings.Error.error, excObj.cause.localizedMessage);
    },

    submit:function(){

        var _complete=function(data) {
            var status=kw.Service.Util.getOpStatus(data);
            if (status.errorCount>0)
                this.handleResults(data.operationStatusSet, true /* throw summary error*/);

            var actionArgs=new kw.ActionArgs({
             context: this.actionArgs.context,
             notification: String.format(kw.Strings.Dialog.DatatableImport.importSuccessful, this.importFileName)
            });
      
            var res=kw.Util.getProgressRes(kw.Strings.Progress.Import, 1, this.importFileName);
            kw.AsyncServiceMgr.get().handleOpStatus(data, res, {fn:this.onImportFileSuccess, scope:this, args:[actionArgs]});
            this.close();
        };

        this.importFileName = this.filechooser_ctrl.getValue();
        
        var profile = new ImportProfile();
        profile.richtextIsHtml = this.useHTML.getValue();
        var callbacks = kw.getCallbackClosure(this, _complete);
        DataTableImportService.importRows(this.dtObjIdentity, this.fileContent, profile, callbacks)

        this.close();
    },

    onImportFileSuccess: function(data, actionArgs) {
        kw.Events.publish(kw.EventNames.DtImportCompleted, actionArgs);
        kw.Events.publish(kw.EventNames.ContainerChanged, actionArgs);
    }
});  // end extend


/* DtFilter.js */

kw.ScriptLoader.require("js/kw/SchemaControlFactory.js");
rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/TextSearchField.js");
rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/NumberSearchField.js");
rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/MemberSearchField.js");

Ext.namespace('kw.widget.datatable');

kw.widget.datatable.SearchTool = function(config)
{
    var summaryGrid = config.actionArgs.component;
    if (summaryGrid.isAdvFiltersInEffect()) {
        config.emptyText = kw.Strings.Action.Pro.Datatable.Filter._advFiltersInEffect;
    } else {
        config.emptyText = kw.Strings.Action.Pro.Datatable.Filter._emptyText;
        config.value = config.actionArgs.component.getFullTextFilterVal();
    }
    kw.widget.datatable.SearchTool.superclass.constructor.call(this, config);
    this.subscription = kw.Events.subscribe(kw.EventNames.DtNoSearchFilter, this.onClear, this);

    this.on('specialkey', function(f, e){
            if(e.getKey() == e.ENTER){
                e.stopEvent();
                this.onTrigger1Click();
            }
    }, this);
};

kw.widget.datatable.SearchTool.setupFullTextFilter = function(summaryGrid, exprSetFilters, fullTextVal) {
    var fullTextFilter = null;
    if (exprSetFilters) {
        for (var i=0, len=exprSetFilters.length; i<len; i++) {
            if (exprSetFilters[i].filterId == "fulltext") {
                fullTextFilter = exprSetFilters[i];
            }
        }
    }
    
    if (!Ext.isEmpty(fullTextVal)) {
        if (!fullTextFilter)  {
            fullTextFilter = new ExpressionSetFilter();
            fullTextFilter.filterId = "fulltext";
            var fullTextSet = {expressions:[], operator:"OR"};
            var fullTextExpression = new FullTextExpression();
            fullTextExpression.value = fullTextVal;
            fullTextSet.expressions.push(fullTextExpression);
            fullTextFilter.expressionSet = fullTextSet;
            if (!exprSetFilters)
                exprSetFilters = [];
            exprSetFilters.push(fullTextFilter);
        }
        else {
            fullTextFilter.expressionSet.expressions[0].value = fullTextVal;
        }
    }
    else {
        if (fullTextFilter) {
            exprSetFilters.remove(fullTextFilter);    
        }
    }
    return exprSetFilters;
};

Ext.extend (kw.widget.datatable.SearchTool, Ext.form.TwinTriggerField, {
    trigger1Class:'x-form-search-trigger',
    ctCls: "kw-dt-search-tool",
    width: 212,
    
    initComponent : function(){

        this.triggerConfig = {
            tag:'div', cls:'x-form-twin-triggers', cn:[
            {tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.trigger1Class,
                qtip: kw.Strings.Action.Pro.Datatable.Filter._searchTooltip},
            {tag: "img", src: Ext.BLANK_IMAGE_URL, cls: "x-form-trigger " + this.trigger2Class,
                qtip: kw.Strings.Action.Pro.Datatable.Filter._advSearchTooltip}
        ]};
        kw.widget.datatable.SearchTool.superclass.initComponent.call(this);

    },

    // Triggered when clicked on search button.
    onTrigger1Click : function(){
        var summaryGrid = this.actionArgs.component;
        var fullTextVal = this.getValue();
        var exprSetFilters = summaryGrid.getSearchFilters();
        if (summaryGrid.isAdvFiltersInEffect(exprSetFilters)) {
            this.emptyText = kw.Strings.Action.Pro.Datatable.Filter._advFiltersInEffect;
            this.setValue("");
            // Something else must get focus, say the global help button
            this.triggerBlur();
            var globalHelpBtn = Ext.DomQuery.select(".kw-help")[0];
            globalHelpBtn.focus();
            globalHelpBtn.blur();
        } else {
            this.emptyText = kw.Strings.Action.Pro.Datatable.Filter._emptyText;
        }
        exprSetFilters = kw.widget.datatable.SearchTool.setupFullTextFilter(summaryGrid, exprSetFilters, fullTextVal);

        if (kw.PagingToolbar.hasSavedGridPage(location.href, summaryGrid.context.id, summaryGrid._dataStore.queryId))
            kw.PagingToolbar.clearSavedGridPage();
        
        summaryGrid.setupForSearchService(exprSetFilters, true);

        kw.Events.publish(kw.EventNames.DtSearchFilterPrint, {
             searchFilterStrExp: summaryGrid.getSearchFilterExpStr()
         });
        
    },
    
    onTrigger2Click : function(){
        if (this.hasFocus)
            this.actionArgs.fullTextVal = this.getValue();
        else
            delete this.actionArgs.fullTextVal;
        this.actionArgs.searchTwinTriggerField = this;
        kw.ActionManager.showDialog(kw.widget.datatable.SearchFilter, this.actionArgs,
            {x: this.el.getLeft(), y:this.el.getTop()});
    },

    onClear : function(eventName, data) {
        var summaryGrid = this.actionArgs.component;
        if (summaryGrid.context.id != data.datatableId)
            return;

        this.emptyText = kw.Strings.Action.Pro.Datatable.Filter._emptyText;
        this.setValue("");
    },

    onDestroy : function() {
        kw.Events.unsubscribe(this.subscription);
        kw.widget.datatable.SearchTool.superclass.onDestroy.call(this);
    }
});

kw.widget.datatable.FilterStatus = function(config) {
    kw.widget.datatable.FilterStatus.superclass.constructor.call(this, config);
    this.onInitialize();
    this.subscriptions = [];
    this.subscriptions.push(kw.Events.subscribe(kw.EventNames.DtSearchStatus, this.onUpdate, this));
    this.subscriptions.push(kw.Events.subscribe(kw.EventNames.DtNoSearchFilter, this.onClearFilter, this));
};

Ext.extend (kw.widget.datatable.FilterStatus, Ext.Toolbar.TextItem, {
    cls: "kw-dt-filter-status",
    hidden: true,

    onInitialize : function() {
        var summaryGridStore = this.actionArgs.component._dataStore;
        if (typeof summaryGridStore.totalFilterMatches != "undefined") {
            this.setFilterStatus(summaryGridStore.totalFilterMatches,
                    summaryGridStore.totalEntries, summaryGridStore.hasMoreResults);
        }
    },

    setFilterStatus : function(totalFilterMatches, totalEntries, hasMoreResults) {
        var msg = String.format(kw.Strings.Action.Pro.Datatable.FilterStatus._text,
                totalFilterMatches, totalEntries);
        if (hasMoreResults)
            msg = msg + " <img class='kw-dt-filter-limit' src='" + kw.ScriptLoader.getImagePath() + "icons/information.png' qtip='" +
                    kw.Strings.Action.Pro.Datatable.FilterStatus._limit + "'>";
        this.setText(msg);
        this.show();
    },

    onUpdate : function(eventName, data) {
        var summaryGrid = this.actionArgs.component;
        if (summaryGrid.context.id != data.datatableId)
            return;

        this.setFilterStatus(data.totalFilterMatches, data.totalEntries, data.hasMoreResults);

        Ext.apply(summaryGrid._dataStore,
            {totalFilterMatches: data.totalFilterMatches, totalEntries: data.totalEntries,
             hasMoreResults: data.hasMoreResults});

        kw.Events.publish(kw.EventNames.DtSearchFilterPrint, {
             searchFilterStrExp: summaryGrid.getSearchFilterExpStr()
         });

    },

    onClearFilter : function(eventName, data) {
        if (this.actionArgs.component.context.id != data.datatableId)
            return;

        this.hide();
    },

    onDestroy : function() {
        for (var i=0, len=this.subscriptions.length; i<len; i++)
            kw.Events.unsubscribe(this.subscriptions[i]);
        kw.widget.datatable.FilterStatus.superclass.onDestroy.call(this);
    }
});
// Hidden toolbar item to store the search filter exp, required for print option
kw.widget.datatable.SearchFilterExpStr = function(config) {
    kw.widget.datatable.SearchFilterExpStr.superclass.constructor.call(this, config);
    this.subscriptions = [];
    this.subscriptions.push(kw.Events.subscribe(kw.EventNames.DtSearchFilterPrint, this.updateSearchFilterExpStr, this));
};

Ext.extend (kw.widget.datatable.SearchFilterExpStr, Ext.Toolbar.TextItem, {
    cls: "kw-dt-search-filter-exp",
    hidden: true,

    updateSearchFilterExpStr : function(eventName, data) {
        this.setText(data.searchFilterStrExp);
    },

    onDestroy : function() {
        for (var i=0, len=this.subscriptions.length; i<len; i++)
            kw.Events.unsubscribe(this.subscriptions[i]);
        kw.widget.datatable.FilterStatus.superclass.onDestroy.call(this);
    }
});

kw.widget.datatable.ClearFilter = function(config) {
    kw.widget.datatable.ClearFilter.superclass.constructor.call(this, config);
    this.onInitialize();
    this.subscriptions = [];
    this.subscriptions.push(kw.Events.subscribe(kw.EventNames.DtSearchStatus, this.onUpdate, this));
    this.subscriptions.push(kw.Events.subscribe(kw.EventNames.DtNoSearchFilter, this.onClearFilter, this));
};

Ext.extend(kw.widget.datatable.ClearFilter, Ext.Toolbar.Item, {
    cls:"kw-datatable-clear-filter",
    overCls: "kw-datatable-clear-filter-over",
    tooltip: kw.Strings.Action.Pro.Datatable.ClearFilter._tooltip,
    hidden: true,
    handler: function() {
        var summaryGrid = this.actionArgs.component;

        if (kw.PagingToolbar.hasSavedGridPage(location.href, summaryGrid.context.id, summaryGrid._dataStore.queryId))
            kw.PagingToolbar.clearSavedGridPage();
        
        summaryGrid.setupForListService(true);
    },

    onInitialize : function() {
        var summaryGridStore = this.actionArgs.component._dataStore;
        if (typeof summaryGridStore.totalFilterMatches != "undefined") {
            this.show();
        }
    },

    onRender: function(ct, position) {
        var div = document.createElement("div");
        ct.dom.insertBefore(div, position);
        div.qtip = this.tooltip;
        this.el = Ext.get(div);
        this.mon(this.el, "click", this.handler, this);
    },

    onUpdate : function(eventName, data) {
        if (this.actionArgs.component.context.id != data.datatableId)
            return;

        this.show();
    },

    onClearFilter: function() {
        this.hide();
    },
    
    onDestroy : function() {
        for (var i=0, len=this.subscriptions.length; i<len; i++)
            kw.Events.unsubscribe(this.subscriptions[i]);
        kw.widget.datatable.ClearFilter.superclass.onDestroy.call(this);
    }
});

kw.widget.datatable.SearchFilter = function(config){
    Ext.applyIf(config, {
        width:400,
		maxWidth:550,
        height: 465,
        autoFocus: true,
        cls: "kw-dt-search-dialog",  
        buttons: [
             {
                 text: kw.Strings.Action.Pro.Datatable.Filter._btnSearch,
                 handler: this.search,
                 scope: this
             },
             {
                 text: kw.Strings.Action.Pro.Datatable.Filter._btnReset,
                 handler: this.resetFilter,
                 scope: this
             },
             {
                 text: kw.Strings.btnClose,
                 handler: this.close,
                 scope: this
             } 
        ]
    });

    kw.widget.datatable.SearchFilter.superclass.constructor.call(this, config);
};

Ext.extend(kw.widget.datatable.SearchFilter, kw.Dialog.DialogBase, {
    resizable:"true",
    
    initialize:function()
	{
        var propertyPackage = this.getSearchParams();

        this._schemaControl = new kw.Dialog.SchemaControlFactory({
             container: this,
             typeInfo: propertyPackage.typeInfo,
             properties: propertyPackage.properties,
			 outerContainer: {
				xtype: 'fieldset',
				layout: 'form',
				plain: true,
				autoScroll:true
			 },
			 section: null,
			 sectionContainer: null
         });

         var formconfig = this._schemaControl.createFormConfig();
         formconfig.labelAlign = "top";
         this._formpanel = new kw.Dialog.FormPanel(formconfig);
         this.add(this._formpanel);
         this.doLayout();

         kw.widget.datatable.SearchFilter.superclass.initialize.call(this);        
    },

    onRender : function(ct, position){
        kw.widget.datatable.SearchFilter.superclass.onRender.call(this, ct, position);
        this.mask.addClass("kw-dt-filter-mask");
    },

    search: function() {
        var summaryGrid = this.actionArgs.component;
        var searchFields = this._formpanel.items;
        var fullTextVal = searchFields.get(0).getValue();
        var exprSetFilters = this.setupSearchFilters(summaryGrid, fullTextVal, searchFields);
        
        if (summaryGrid.isAdvFiltersInEffect(exprSetFilters)) {
            this.actionArgs.searchTwinTriggerField.emptyText = kw.Strings.Action.Pro.Datatable.Filter._advFiltersInEffect;
            this.actionArgs.searchTwinTriggerField.setValue("");
        }
        else {
            this.actionArgs.searchTwinTriggerField.emptyText = kw.Strings.Action.Pro.Datatable.Filter._emptyText;
            this.actionArgs.searchTwinTriggerField.setValue(fullTextVal);
        }

        if (kw.PagingToolbar.hasSavedGridPage(location.href, summaryGrid.context.id, summaryGrid._dataStore.queryId))
            kw.PagingToolbar.clearSavedGridPage();
        
        summaryGrid.setupForSearchService(exprSetFilters, true);

        kw.Events.publish(kw.EventNames.DtSearchFilterPrint, {
             searchFilterStrExp: summaryGrid.getSearchFilterExpStr()
         });

        this.close();
    },

    setupSearchFilters : function(summaryGrid, fullTextVal, searchFields) {
        var exprSetFilters = kw.widget.datatable.SearchTool.setupFullTextFilter(
                summaryGrid,
                [] /*starts with an empty filter set*/, 
                fullTextVal);

        var columnFilter = new ExpressionSetFilter();
        columnFilter.filterId = "column";

        var expressionSet = {expressions:[], operator:"AND"};
        for (var i=1; i<searchFields.length; i++)
        {
            var searchField = searchFields.get(i);
            var iDtSearchField = rcmp.intf.getInterface(searchField, "kw.component.IDtSearchField");
            var searchExpressions = iDtSearchField.getSearchExpressions();
            if (searchExpressions) {
                expressionSet.expressions.push(searchExpressions)
            }
        }

        if (expressionSet.expressions.length) {
            columnFilter.expressionSet = expressionSet;
            exprSetFilters.push(columnFilter);
        }

        return exprSetFilters;
    },


    resetFilter: function() {
        var searchFields = this._formpanel.items;
        searchFields.get(0).setValue("");
        for (var i=1; i<searchFields.length; i++)
        {
            var searchField = searchFields.get(i);
            var iDtSearchField = rcmp.intf.getInterface(searchField, "kw.component.IDtSearchField");
            iDtSearchField.resetSearchFilter();
        }
    },

    getSearchParams: function()
    {
        var properties = new Object();

        var typeInfo = new TypeInfo();
        typeInfo.name = '';
        typeInfo.label = '';
        typeInfo.description = '';

        var propertyDisplayInfos = [];
        var propertyInfos = [];

        var summaryGrid = this.actionArgs.component;
        
        // full text search param
        var fullTextVal = this.actionArgs.fullTextVal;
        if (fullTextVal == undefined)
            fullTextVal = summaryGrid.getFullTextFilterVal();
        properties["kw-dt-fulltext-search"] = fullTextVal;

        propertyDisplayInfos.push({
            propertyName: "kw-dt-fulltext-search",
            separator:false,
            secondary:false});
        var propInfo =  {
            name: "kw-dt-fulltext-search",
            label: kw.Strings.Datatable.fullTextSearchLabel,
            labelStyle: 'font-weight:bold;',
            dataType: kw.DataType.STRING
        };
        propertyInfos.push(propInfo);

        var columnFilterExpressions = summaryGrid.getColumnFilters();
                
        var meta = this.actionArgs.context.getContextProperties();
        var searchableColumns = kw.Util.deepClone(meta.get("_kw_summary_settings").searchableColumns);
        searchableColumns.unshift("r_modify_date");
        searchableColumns.unshift("r_modifier");

        for (var i=0; i<searchableColumns.length; i++) {
            var columnId = searchableColumns[i];
            var columnDef = summaryGrid.getColumnDef(columnId);
            if (!columnDef)
                continue;

            var searchControlInfo = this.getSearchControlInfo(columnDef);
            if (!searchControlInfo.xtype)
                searchControlInfo.xtype = "textsearchfield";

            var dueDateColumnId = columnId + "_is_done";
            for (var y=0; y<columnFilterExpressions.length; y++) {
                if (columnFilterExpressions[y].property == columnId ||
                    columnFilterExpressions[y].property == dueDateColumnId ||
                    (columnFilterExpressions[y].expressions && columnFilterExpressions[y].expressions.length &&
                     columnFilterExpressions[y].expressions[0].property == columnId)) {
                    var configOptions = Ext.util.JSON.decode(searchControlInfo.configOptions);
                    configOptions.searchExpression = columnFilterExpressions[y];
                    searchControlInfo.configOptions = Ext.util.JSON.encode(configOptions);
                }
            }

            properties[columnId] = "";
            propertyDisplayInfos.push({
                propertyName: columnId,
                separator:false,
                secondary:false});
            var dataType;
            var propInfo =  {
                name: columnId,
                label: Ext.util.Format.htmlEncode(columnDef.columnLabel),
                labelStyle: 'font-weight:bold;',
                dataType: dataType,
                xtype: searchControlInfo.xtype,
                configOptions: searchControlInfo.configOptions
            };
            propertyInfos.push(propInfo);
        }

        typeInfo.displayInfos = [{
            label: "",
            name: "",
            propertyDisplayInfos: propertyDisplayInfos
        }];

        typeInfo.propertyInfos = propertyInfos;

        var propPackage = new PropertyPackage();
        propPackage.properties=properties;
        propPackage.typeInfo = typeInfo;

        return propPackage;
    },

    getSearchControlInfo : function(columnDef) {
        var componentId = columnDef.renderType;

        if (columnDef.columnName == "r_modify_date")
            componentId = "cma.kw.form.DateField";

        if(columnDef.columnName == "r_modifier"){
            componentId = "cma.kw.form.MemberList";
            columnDef.columnLabel = kw.Strings.Datatable.lastChangedBy;
        }
        
        var displayConfig = kw.RcmpBinding.getDisplayConfig(componentId);
        
        var searchControlInfo = {};
        searchControlInfo.xtype = displayConfig.attributes["searchxtype"];

        var configOptions = Ext.util.JSON.decode(displayConfig.attributes["searchConfigOptions"]);
        if (!configOptions) {
            configOptions = {};
        }
        configOptions.dtFieldInfo = columnDef;

        searchControlInfo.configOptions = Ext.util.JSON.encode(configOptions);

        var srcFile = displayConfig.attributes["searchSrcFile"];
        if (srcFile) {
            var nameSpace = rcmp.ComponentRegistry.getComponentDefinition(componentId).getURLNameSpace();            
            var uri= rcmp.core.Environment.makeURL(nameSpace, srcFile);
            rcmp.resource.ResourceLoader.loadJS(uri);
        }

        if (columnDef.columnName == "r_modifier"){
            searchControlInfo.xtype = "membersearchfield";
        }

        return searchControlInfo;
    }
});


/* DtOptions.js */

rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/FieldSettings.js");
kw.ScriptLoader.requireStrings("Datatable");
kw.ScriptLoader.require("js/kw/widget/form/FieldPlugIn.js");

Ext.namespace("kw.widget.datatable");

kw.widget.datatable.DtOptions = Ext.extend(Ext.Panel,
{
    constructor: function(config)
    {
        kw.widget.datatable.DtOptions.superclass.constructor.call(this,config);
        this.cls = 'kw-dt-options';
    },

    onRender: function(ct, pos)
    {
        this.initializeControls();
        kw.widget.datatable.DtOptions.superclass.onRender.call(this, ct, pos);

        this.rowControl = kw.widget.datatable.getRowControlForWidget(this);
        this.rowControl.allowComments = this.allowComments;
        this.rowControl.pageControl.on(kw.EventNames.PageModified, this.updateControls, this);
        this.rowControl.pageControl.on('beforexulgeneration', this.onBeforeXulGeneration, this);
        this.entryNameComboBox.on('select', this.onEntryNameSelect, this);
        this.updateControls({ reason: 'initial_binding'});
    },

    onEntryNameSelect: function(combo, record, index)
    {
        this.fieldSettingsEditor.entries.addToList(record);
        this.fieldSettingsEditor.filters.addToList(record);

        //notify the schema to enable 'remove' tool button for the previous title widget,
        //and disable the 'remove' tool button for the new title widget

        this.setWidgetAsTitle(this.titleColumnRecord, false);
        this.setWidgetAsTitle(record, true);

        this.titleColumnRecord = record;
    },

    setWidgetAsTitle: function(record, state)
    {
        var wid = record.data.wid;
        var f = Ext.getCmp(wid);
        f.setAsTitle(state);
    },

    onBeforeXulGeneration: function(properties, propertyMap)
    {
        properties._kw_enable_comments = this.allowComments.getValue();
        propertyMap.push({name: '_kw_enable_comments', type: 'ns3:BooleanProperty'});

        //properties._kw_enable_changelog = this.trackChanges.getValue();
        //propertyMap.push({name: '_kw_enable_changelog', type: 'ns3:BooleanProperty'});

        properties.title_column = this.entryNameComboBox.getRawValue();
        propertyMap.push({name: 'title_column', type: 'ns3:StringProperty'});

        properties._kw_summary_settings =
        {
            summaryColumns: this.fieldSettingsEditor.entries.getList('name'),
            searchableColumns:this.fieldSettingsEditor.filters.getList('name')
        };

        propertyMap.push({name: '_kw_summary_settings', type: 'collab:DataTableSummary'});

        properties.r_object_id = this.rowControl.datatableId;
        propertyMap.push({name: 'r_object_id', type: 'ns3:ObjectIdProperty'});
    },

    getFieldAttributes: function(fields, fieldId)
    {
        for (var i = 0; i < fields.length; i++)
        {
            if (fieldId == fields[i].fieldId)
            {
                 var dispCfg = kw.RcmpBinding.getDisplayConfig(fields[i].rcmpId);
                 if (dispCfg)
                     return dispCfg.attributes;
                 break;
            }
        }
        return undefined;
    },

    getEntryNameFields: function(fields)
    {
        var entryNameFields = [];
        for (var i = 0; i < fields.length; i++)
        {
            var field = fields[i];
            var dispCfg = kw.RcmpBinding.getDisplayConfig(field.rcmpId);
            if (dispCfg && dispCfg.attributes && dispCfg.attributes.isTitle)
                entryNameFields.push(field);
        }
        return entryNameFields;
    },

    getStoreData: function(fields, which, allowEmpty)
    {
        var data = [];
        for (var i=0; i<fields.length; i++)
        {
            var field = fields[i];
            var addField = false;

            var fieldTitle = field.title ? field.title.trim() : "";
            if (!allowEmpty && Ext.isEmpty(fieldTitle))
                continue;

            var dispCfg  = kw.RcmpBinding.getDisplayConfig(field.rcmpId);
            if (dispCfg && dispCfg.attributes)
            {
                var attributes = dispCfg.attributes;
                if (which == 'title')
                    addField = attributes.isTitle;
                else
                if (which == 'main')
                    addField = (attributes.isSummaryField || attributes.isSearchable);

                if (addField)
                    data.push([fieldTitle, field.fieldId, field.widgetId, field.rcmpId, attributes]);
            }
        }
        return data;
    },

    updateControls: function(evtArgs)
    {
        var meta   = this.rowControl.context.getContextProperties();
        var reason = (evtArgs != undefined) ? evtArgs.reason : undefined;
        var fields = this.rowControl.getFieldsFromLayout();

        var entryNameFields = this.getEntryNameFields(fields);
        var entryNameStoreData = this.getStoreData(entryNameFields, 'title', (reason == 'add'));
        var entryNameStore = this.entryNameComboBox.store;
        entryNameStore.loadData(entryNameStoreData);

        var mainFieldsStoreData = this.getStoreData(fields, 'main', (reason == 'add'));
        var localeFieldNames = ['name', 'fid', 'wid'];
        var mainFieldsStore = new Ext.data.SimpleStore({fields: localeFieldNames, data: mainFieldsStoreData});

        var titleColumnId;
        if (reason == 'initial_binding')
        {
            titleColumnId = meta.get('title_column');
            if (!titleColumnId)
                titleColumnId = entryNameStoreData[0][1];

            //  initialize titleColumnRecord
            var index = entryNameStore.find('fid',titleColumnId);
            this.titleColumnRecord = entryNameStore.getAt(index);

            //  initialize portlet toolbar on title column widget
            this.setWidgetAsTitle(this.titleColumnRecord, true);

            this.allowComments.setValue(meta.get('_kw_enable_comments'));
        }
        else
        {
            //  update titleColumnRecord name in case it has changed (reason == 'config')
            titleColumnId = this.titleColumnRecord.data.fid;
            var record = entryNameStore.getAt( entryNameStore.find('fid', titleColumnId) );
            if (record && record.data && record.data.name)
            {
                if (this.titleColumnRecord.data.name != record.data.name)
                    this.titleColumnRecord.data.name = record.data.name;
            }
        }

        var entryName = this.titleColumnRecord.data.name;

        //  Update entryName combo box selection
        if (this.entryNameComboBox.getValue() != entryName)
            this.entryNameComboBox.setValue(entryName);

        //  Update master list
        var mainFieldListStoreData = this.getStoreData(fields, 'main', false);
        var editor = this.fieldSettingsEditor;
        editor.setMainFieldList(mainFieldListStoreData);

        switch (reason)
        {
            case 'add':
            {
                //  Find column just added:  it will have an empty name.
                //  Add it to summary and filter lists if appropriate.
                var items = mainFieldsStore.data.items;
                for (var i = 0; i < items.length; i++)
                {
                    var item_data = items[i].data;
                    if (item_data.name.length == 0)
                    {
                        var attributes = this.getFieldAttributes(fields,item_data.fid);
                        if (attributes)
                        {
                            if (attributes.isSummaryField)
                                editor.entries.addToList(items[i]);
                            if (attributes.isSearchable)
                                editor.filters.addToList(items[i]);
                        }
                        break;
                    }
                }
                break;
            }
            case 'delete':
            {
                //  Remove deleted field from 'entries' and 'filters' lists
                editor.removeDeletedFromEntries();
                editor.removeDeletedFromFilters();
                break;
            }
            case 'config':
            {
                //  Update field display name in 'entries' and 'filters' lists
                editor.updateEntries();
                editor.updateFilters();
                break;
            }
            case 'layout':
            {
                break;
            }
            default:
            {
                function setList(fieldList, columns)
                {
                    if (!columns || columns.length == 0)
                        return;

                    var records = [];
                    for (var i = 0; i < columns.length; i++)
                    {
                        var fid = columns[i];
                        var record = editor.lookup(fid);
                        if (record)
                            records.push(record);
                    }

                    fieldList.setList(records);
                }

                if (reason == 'initial_binding')
                {
                    var summarySettings = meta.get('_kw_summary_settings');
                    setList(editor.entries, summarySettings.summaryColumns);
                    setList(editor.filters, summarySettings.searchableColumns);
                }

                //  Make sure 'title column' is in 'entries' and 'filters' lists
                editor.entries.addToList(this.titleColumnRecord);
                editor.filters.addToList(this.titleColumnRecord);
                break;
            }
        }
    },

    initializeControls: function()
    {
        var panel, label;

        //  Add Allow Comments check box
        this.allowComments = new Ext.form.Checkbox({boxLabel: kw.Strings.Datatable.allowCommentsOnEntries});
        //this.trackChanges = new Ext.form.Checkbox({boxLabel: kw.Strings.Datatable.trackChangesToEntries})
        //this.entryOptions = new Ext.Panel({cls: 'kw-dt-options-sub-panel kwdots_below', items: [this.allowComments, this.trackChanges]});
        this.entryOptions = new Ext.Panel({cls: 'kw-dt-options-sub-panel kwdots_below', items: [this.allowComments]});
        this.add(this.entryOptions);

        //  Add Entry Title Picker label and control
        label = new Ext.form.Label({cls: 'kw-dt-options-label', text: kw.Strings.Datatable.entryName});
        var localeFieldNames = ['name', 'fid', 'wid'];
        this.entryNameComboBox = new Ext.form.ComboBox(
        {
            name: 'entryName',
            hiddenName: 'entryName',
            editable: false,
            forceSelection: true,
            store: new Ext.data.SimpleStore({fields: localeFieldNames, data: []}),
            displayField: 'name',
            valueField: 'fid',
            tpl: '<tpl for="."><div class="x-combo-list-item">{name:htmlEncode}</div></tpl>',
            plugins: new kw.widget.FieldPlugIn({helpText: kw.Strings.Datatable.entryNameHelpText}),
            tpl: '<tpl for="."><div class="x-combo-list-item">{' + localeFieldNames[0] + ':htmlEncode}</div></tpl>',
            mode: 'local',
            triggerAction: 'all'
        });
        this.entryNamePicker = new Ext.Panel(
        {
            cls: 'kw-dt-entry-name-picker',
            items: [this.entryNameComboBox]
        });
        panel = new Ext.Panel({cls: 'kw-dt-options-sub-panel kwdots_below', items: [label,this.entryNamePicker]});
        this.add(panel);

        //  Add Entry List Field Options label and controls
        label = new Ext.form.Label({cls: 'kw-dt-options-label', text: kw.Strings.Datatable.entriesListOptions});
        this.fieldSettingsEditor = new kw.widget.FieldSettings.Panel({data: [], dtOptions: this});
        panel = new Ext.Panel({cls: 'kw-dt-options-sub-panel kwdots_below', items: [label, this.fieldSettingsEditor]});
        this.add(panel);
    },

    getTitleColumnId: function()
    {
        return this.titleColumnRecord.data.fid;
    }

});

Ext.reg('kwdtoptions', kw.widget.datatable.DtOptions);

/* DtProperties.js */

Ext.namespace("kw");

(function() {
    kw.DataTableProperties = function(config) {
        kw.DataTableProperties.superclass.constructor.call(this, config);
    }

    Ext.extend(kw.DataTableProperties, kw.Properties, {
        getFields: function() {
            return this.get("fieldsInfo");
        },
        set: function(propName, value) {
            if (!this._items) {
                this._items = {};
            }
            this._items[propName] = value;
        }
    });
})();

/*
 * Copyright (c) 2009-2010 EMC Corporation. All Rights Reserved.
 */

Ext.namespace("kw.data");
kw.ScriptLoader.require("js/kw/ServiceResultReader.js");
kw.ScriptLoader.require("js/kw/Events.js");

(function() {

kw.data.DtSearchServiceResultsReader = function(){
    kw.data.DtSearchServiceResultsReader.superclass.constructor.call(this);
};
Ext.extend(kw.data.DtSearchServiceResultsReader, kw.data.ServiceResultsReader, {

    read : function(params, results) {
        kw.Events.publish(kw.EventNames.DtSearchStatus, {
            datatableId: params.serviceMethodParams.filter.parameters[0].value,
            totalFilterMatches: results.filteredItemsCount,
            hasMoreResults: results.status.hasMoreResults, 
            totalEntries: results.totalItemsCount
        });
    	var ret = kw.data.DtSearchServiceResultsReader.superclass.read.call(this, params,results);
        ret.totalRecords =  results.filteredItemsCount;
        return ret;
    }
});

})();


/* DtTitleArea.js */

kw.ScriptLoader.require("js/kw/widget/PageTitleBar.js");
(function() {

function dtPageTitle(str) {
    var titleEl = this.el.child(".kw-pagename");
    var infoEl = this.el.child(".kw-text-non-editable");
    if (!titleEl){
        this.doLayout(false, true);
        titleEl = this.el.child(".kw-pagename");
    }
    if (titleEl)
        titleEl.update(Ext.util.Format.htmlEncode(str));
    
    if(infoEl && this.rowControl.isNewEntry()){
        infoEl.setVisibilityMode(Ext.Element.DISPLAY);
        infoEl.setVisible(false);
    }        
    
    kw.Util.setPageTitle(str, this);
}

// this is used on the Entry page
kw.widget.DatatableTitleArea = function(config){

    Ext.applyIf(config,{
        containername:"kw.dt.entry.view.toolbar",
        editcontainername:"kw.dt.entry.edit.toolbar"});

    kw.widget.DatatableTitleArea.superclass.constructor.call(this, config);
};

Ext.extend(kw.widget.DatatableTitleArea, kw.widget.PageTitleBar, {

    onRender: function(ct, pos) {
        kw.widget.DatatableTitleArea.superclass.onRender.apply(this, arguments);
        this.errorBox = this.add({xtype: "kwvbox", html: kw.Strings.Datatable.formErrors, cls: "kw-dte-title-error"});
        this.doLayout();
        this.rowControl = kw.widget.datatable.getRowControlForWidget(this);
        this.rowControl.on("loadrecord", this.onLoadRecord, this);
        this.rowControl.on("updateemailaddr", this.onUpdateEmailAddr, this);
        this.rowControl.on(kw.EventNames.UpdateDtEntryToolbar, this.setToolbar, this);
        if (this.rowControl.isNewEntry()) {            
            dtPageTitle.call(this, kw.Strings.Datatable.newEntryName);
            this.el.child(".kw-pagename").addClass('kw-new-entry');
        }  
        else {  //KWC-18009; bad assumption; .record is not always here!
            var meta = (this.rowControl.record) ? this.rowControl.record: this.rowControl.context.getContextProperties();
            this.updatePageTitle(meta.get("object_name"));
        }
        this.setLeftToolbar();
    },

    onLoadRecord: function(rec) {
        if (this.namePanel)
            this.updatePageTitle(this.rowControl.record.get("object_name"));
        if (this.infoPanel) {
            var meta = this.rowControl.context.getContextProperties();
            var names = [meta.get("r_creator_name"),
                meta.get("r_modifier"),
                meta.get("r_lock_owner")];
            this.membersMissingEmailAddrInfo = new Array();
            for (var i=0; i<names.length; i++) {
                if (!Ext.isEmpty(names[i]) &&
                    !kw.EmailAddressCache.getEmailAddress(names[i], true) &&
                    this.membersMissingEmailAddrInfo.indexOf(names[i]) == -1) {
                    this.membersMissingEmailAddrInfo.push(names[i]);
                }
            }
            this.infoPanel.getContentTarget().dom.innerHTML = kw.Util.getPageInfoMarkup(this.rowControl.context);
        }
        this.updateActions();
    },

    onUpdateEmailAddr: function() {
        if (this.membersMissingEmailAddrInfo.length > 0 && this.infoPanel) {
            kw.EmailAddressCache.updateCache(this.membersMissingEmailAddrInfo);
            this.infoPanel.getContentTarget().dom.innerHTML = kw.Util.getPageInfoMarkup(this.rowControl.context);
        }
    },

    showErrorBox: function(showIt) {
        if (this.errorBox.el.dom) {
            this.errorBox.el.dom.style.display = showIt ? "block" : "none";
            if(showIt) { // scroll to top                     v
                var container = Ext.get(this.el.findParentNode('.kw-dtentry-new'));
                if(container) container.scrollTo('top', 0, true);
            }
        }
    },

    onPagePropsModified: function(name, actionArgs) { // overrides base class method
        var entryId = this.rowControl.context.id;
        if (entryId == actionArgs.metadata.get("r_object_id")) {
            var newEntryName = actionArgs.metadata.get("object_name");
            this.updatePageTitle(newEntryName);
        }
    },

    updatePageTitle: function(newEntryName) {
        if (newEntryName) {   //KWC-18009
            if ((typeof newEntryName != "undefined") && newEntryName.bodyAsString) {
                // massage rich text string
                newEntryName = Ext.util.Format.stripTags(newEntryName.bodyAsString);
                newEntryName = Ext.util.Format.htmlDecode(newEntryName.replace(/&nbsp;/g, ' ')).trim();
                if (newEntryName.length > 32)
                    newEntryName = newEntryName.substr(0, 32);
            }
        }
        else
            newEntryName = kw.Strings.Datatable.UnTitledEntry;
        dtPageTitle.call(this, newEntryName);
    },

    setLeftToolbar: function() {
        var actionArgsProvider = this.pc.actionArgsProvider.createDelegate(this.pc);
        if (!this._setToolbarLeft){
            var viewcontrol = kw.widget.ViewControl.getViewControlFromWidget(this);
            var tb = new kw.Toolbar({context:this.context, containername:"kw.dt.entry.view.toolbarLeft",
                     cls:"kw-xh-tool",  actionArgsProvider: actionArgsProvider});

            viewcontrol.setLeftToolbar(tb, true);
            this._setToolbarLeft = true;
        }
    }
});

// -------------------------------------------------------------------

// this is used on the Master page
kw.widget.SchemaTitleArea = function(config){
    Ext.applyIf(config,{
        containername:null,    // schema page doesn't have a view toolbar.
        editcontainername:"kw.page.schematoolbar"});
    kw.widget.SchemaTitleArea.superclass.constructor.call(this, config);
};

Ext.extend(kw.widget.SchemaTitleArea, kw.widget.PageTitleBar, {
    bSuppressNamePanel: false,
    bSuppressTitleEdit: true,
    bSuppressInfoPanel: true,

    setupEditor: function() {},

    onRender: function() {
        function setIt(tbl) {
            var schemaTitleTpl = "{0}" + kw.Strings.formFieldLabelSeparator + " {1}";
            var schemaTitle = String.format(schemaTitleTpl, kw.Strings.Datatable.fieldsSettings, tbl);
            schemaTitle = schemaTitle.replace(/&nbsp;/g, ' ');
            dtPageTitle.call(this, schemaTitle);

            //Get breadcrumbs and rebuild them properly
            var viewcontrol=kw.widget.ViewControl.getViewControlFromWidget(this);
            if (viewcontrol) {
                var breadcrumbs=viewcontrol.getBreadcrumbs();
                if (breadcrumbs)
                    breadcrumbs.updateLastCrumb({objectName: tbl, id: {id:this.rowControl.datatableId}});
            }
        }
        kw.widget.SchemaTitleArea.superclass.onRender.apply(this, arguments);
        this.errorBox = this.add({xtype: "kwvbox", html: kw.Strings.Datatable.formErrors, cls: "kw-dte-title-error"});
        this.doLayout();
        this.rowControl = kw.widget.datatable.getRowControlForWidget(this);

        var tableName = kw.data.DtMetadataCache.getProperty(this.rowControl.datatableId, "object_name");
        // normally the name is in the cache, but handle the case where we jump directly to the
        // schema page
        if (!tableName) {
            var identity = new ObjectIdentity();
            Ext.apply(identity, this.context.getObjectIdentity());
            identity.value = this.rowControl.datatableId;
            var options = {propertyProfile: {includeProperties: ["object_name"]}};
            var callbacks = kw.getCallbackClosure(this, {
                callback: function(pkg) {
                    setIt.call(this, pkg.properties.object_name);
                }
            });
            ContentService.getObject(identity, options, callbacks);
        }
        else {
            setIt.call(this, tableName);
        }
        this.pc.addEvents("adddtwidget");
        this.pc.on("adddtwidget", this.onAddDatatableWidget, this);
        this.pc.on(kw.EventNames.PageModified, this.onDatatablePageModified, this);
    },

    getWidgetSelectorConfig: function() {

        if (!kw.widget.PageControl.datatableWidgetList){
            var actionArgs = new kw.ActionArgs({context: this.pc.context, component: Ext.getCmp(this.el.findParent("[_kw_urielem='page']", 20).id)});
            var widgetCategories = [];
            widgetCategories.push("datatable");
            widgetCategories.push("field");
            kw.widget.PageControl.datatableWidgetList = kw.widget.PageControl.loadWidgetList(actionArgs, widgetCategories);

            // We use the cma.kw.RichText component for informational text
            for (var i=0, len=kw.widget.PageControl.datatableWidgetList.length; i<len; i++) {
                if (kw.widget.PageControl.datatableWidgetList[i][4]/*rcmp_sid*/ == "cma.kw.RichText"){

                    kw.widget.PageControl.datatableWidgetList[i][0]/*rcmp_icon*/ =
                        "rcmpserver/componentresources/cma.kw.RichText/icons/cma.kw.InformationalText_24.png";
                    kw.widget.PageControl.datatableWidgetList[i][1]/*rcmp_disabled_icon*/ = "";
                    kw.widget.PageControl.datatableWidgetList[i][2]/*rcmp_name*/ =
                        kw.Strings.Action.Pro.Datatable.AddField._informationalText;
                    kw.widget.PageControl.datatableWidgetList[i][5]/*rcmp_des*/ =
                        kw.Strings.Action.Pro.Datatable.AddField._informationalTextDes;
                    break;
                }                
            }
        }
        return  {
            datatable: true,
            widgetList: kw.widget.PageControl.datatableWidgetList,
            pageControl: this.pc,
            component: Ext.getCmp(this.el.findParent("[_kw_urielem='page']", 20).id),
            context: this.pc.context
        };
    },

    onAddDatatableWidget: function(evtName, ctx) {
        var selectorArea = this.findWidgetSelectorArea();
        if (typeof this.widgetSelector == "undefined") {
            //show the widget selector
            kw.ScriptLoader.require('js/kw/widget/WidgetSelector.js');

            var wsCfg = this.getWidgetSelectorConfig();

            this.widgetSelector = new kw.widget.WidgetSelector(wsCfg);
            this.widgetSelector.hidden = false;
            this.widgetSelector.on("close", this.hideWidgetSelector, this);
            selectorArea.add(this.widgetSelector);
            selectorArea.doLayout();

            var args = new kw.ActionArgs({
                reason: "add"
            });
            this.onDatatablePageModified(args);
        }
        else  {
            if (!this.widgetSelector.hidden)
            {
                this.widgetSelector.hide();
                this.widgetSelector.hidden = true;
            }
            else
            {
                this.widgetSelector.show();
                this.widgetSelector.hidden = false;
            }
        }
        kw.dd.TinyRegistry.deselectAll();    //deselect widgets from pagecontrol to avoid multiple focus issue
        this.pc.box.doLayout();
    },

    isWidgetNotInSchema: function(fields, rcmpId){
        for(var i=0;i < fields.length; i++){
            if (fields[i].rcmpId == rcmpId)
                return false;
        }
        return true;
    },

    onPagePropsModified: function(name, actionArgs) { // overrides base class method
        var dtId = this.rowControl.datatableId;
        if (dtId == actionArgs.metadata.get("r_object_id")) {
            var newDtName = actionArgs.metadata.get("object_name");
            if (newDtName) {
                var schemaTitleTpl = "{0}"+ kw.Strings.formFieldLabelSeparator +" {1}";
                var schemaTitle = String.format(schemaTitleTpl, kw.Strings.Datatable.fieldsSettings, newDtName);
                schemaTitle = schemaTitle.replace(/&nbsp;/g, ' ');
                dtPageTitle.call(this, schemaTitle);
            }
        }
    },

    onDatatablePageModified: function(evtArgs){
        
        if ((evtArgs.reason == "add") || (evtArgs.reason == "delete")){

            this.rowControl = kw.widget.datatable.getRowControlForWidget(this);

            var fields = this.rowControl.getFieldsFromLayout();
            var fieldCount = fields.length;
            var dispCfg, isSingleton, item;
            var maxWidgets = 100;
            
            if(fieldCount == maxWidgets){
                //Disable All Widgets
                for (var i=3; i<this.widgetSelector.view.store.totalLength; i++){

                    item = this.widgetSelector.view.store.data.items[i].data;
                    this.widgetStateChange(item, item.disabled_src, item.name, kw.Strings.Datatable.datatableWidgetsDisabled);
                    Ext.DomQuery.selectNode('.kw-widgetselector-text', item.panel.el.dom).className = "kw-widgetSelector-disabledText kw-widgetselector-text";
                    item.disabled = true;
                }
            }else if(fieldCount == (maxWidgets - 1)){
                if (evtArgs.reason == "delete"){
                    //Enable All Widgets
                    for (var i=3; i<this.widgetSelector.view.store.totalLength; i++){

                        var widgetNeedsEnablement = true;
                        item = this.widgetSelector.view.store.data.items[i].data;
                        if (item.rcmp)
                        {
                            dispCfg = kw.RcmpBinding.getDisplayConfig(item.aid);
                            isSingleton = dispCfg.attributes["isSingleton"];

                            if(isSingleton){
                                // For Singleton widgets enable only if the widget not present on the schema
                                if(!this.isWidgetNotInSchema(fields, item.aid)){
                                    widgetNeedsEnablement = false;                         
                                }
                            }
                        }
                        if (widgetNeedsEnablement){
                            this.widgetStateChange(item, item.src, item.name, item.description);
                            Ext.DomQuery.selectNode('.kw-widgetselector-text', item.panel.el.dom).className = "kw-widgetselector-text";
                            item.disabled = false;
                        }
                        else{
                            this.widgetStateChange(item, item.disabled_src, item.name, item.disabled_des);    
                        }

                    }
                }
            }
            if(evtArgs.reason == "add"  && this.widgetSelector){
                for(var i=0;i < fieldCount; i++){
                    dispCfg = kw.RcmpBinding.getDisplayConfig(fields[i].rcmpId);
                    isSingleton = dispCfg.attributes["isSingleton"];

                    if (isSingleton){
                        for (var j=0; j<this.widgetSelector.view.store.totalLength; j++)
                        {
                            item = this.widgetSelector.view.store.data.items[j].data;
                            if(item.aid == fields[i].rcmpId){
                                //Disable the item in store                                
                                if (!item.disabled)
                                {
                                    this.widgetStateChange(item, item.disabled_src, item.name, item.disabled_des);
                                    Ext.DomQuery.selectNode('.kw-widgetselector-text', item.panel.el.dom).className = "kw-widgetSelector-disabledText kw-widgetselector-text";
                                    item.disabled = true;
                                }
                            }
                        }
                    }
                }
            }
            if(evtArgs.reason == "delete" && this.widgetSelector){
                for (var k=0; k<this.widgetSelector.view.store.totalLength; k++)
                {
                   if (this.widgetSelector.view.store.data.items[k].data.disabled == true){
                        item = this.widgetSelector.view.store.data.items[k].data;
                        if(this.isWidgetNotInSchema(fields, item.aid)){
                            if (item.disabled)
                            {
                                this.widgetStateChange(item, item.src, item.name, item.description);
                                Ext.DomQuery.selectNode('.kw-widgetselector-text', item.panel.el.dom).className = "kw-widgetselector-text";
                                item.disabled = false;
                            }
                        }
                   }
                }
            }
        }
    },
    widgetStateChange: function(item, itemSrc, itemName, itemDesc){
        //Update the Icon and tooltip
        Ext.DomQuery.selectNode('img', item.panel.el.dom).src = itemSrc;
        item.panel.el.dom.getAttributeNode('ext:qtip').value = this.getTooltip(itemName, itemDesc);
        Ext.DomQuery.selectNode('div', item.panel.el.dom).getAttributeNode('ext:qtip').value = this.getTooltip(itemName, itemDesc);
        Ext.DomQuery.selectNode('.x-panel-body', item.panel.el.dom).getAttributeNode('ext:qtip').value = this.getTooltip(itemName, itemDesc);
        Ext.DomQuery.selectNode('.widget-wrap', item.panel.el.dom).getAttributeNode('ext:qtip').value = this.getTooltip(itemName, itemDesc);
        Ext.DomQuery.selectNode('img', item.panel.el.dom).getAttributeNode('ext:qtip').value = this.getTooltip(itemName, itemDesc);
        Ext.DomQuery.selectNode('.kw-widgetselector-text', item.panel.el.dom).getAttributeNode('ext:qtip').value = this.getTooltip(itemName, itemDesc);
    },
    getTooltip: function(name, description) {
                    var _html = [];
                    _html.push("<table><tr><td class='kw-widget-selector-name'>" + name + "</td></tr>");
                    if (description && description != '')
                        _html.push("<tr><td>" + description + "</td></tr>");
                    _html.push("</table>");
                    return _html.join('');
     },
    showErrorBox: function(showIt) {
        if (this.errorBox.el.dom) {
            this.errorBox.el.dom.style.display = showIt ? "block" : "none";
            if(showIt) { // scroll to top                     v
                var container = Ext.get(this.el.findParentNode('.kw-scrollbox-markerforpage'));
                if(container) container.scrollTo('top', 0, true);
            }
        }
    }

});
})();

// EntryComments.js

Ext.namespace("kw.widget.datatable");

kw.ScriptLoader.require("js/kw/widget/CommentList.js");

(function() {
    kw.widget.datatable.EntryComments = Ext.extend(kw.widget.GovernedCommentList, {
        onRender: function() {
            kw.widget.datatable.EntryComments.superclass.onRender.apply(this, arguments);
            this.needReload = false;
            this.rowControl = kw.widget.datatable.getRowControlForWidget(this);
            this.rowControl.on("contextchanged", onContextChanged, this);
        },

        beforeDestroy: function() {
            if (this.rowControl)
                this.rowControl.un("contextchanged", onContextChanged, this);
            
            kw.widget.datatable.EntryComments.superclass.beforeDestroy.call(this);
        },

        expand: function() {
            kw.widget.datatable.EntryComments.superclass.expand.call(this);
            if (this.needReload) {
                this.needReload = false;
                this.commentGrid.loadData();
            }
            else {
                kw.widget.datatable.EntryComments.superclass.expand.call(this);
            }
        }
        
    });

    function onContextChanged() {
        var newCtx = kw.getContext(this.el.dom);
        if (newCtx.id == this.context.id)
            return;

        delete this.context;
        kw.widget.establishContext(this, {context: newCtx});
        this.initConfig.context = this.context;

        if (this.commentGrid) {
            this.commentGrid._dataStore.context = this.context;
            Ext.apply(this.commentGrid._storeLoadParams, {
                serviceMethodParams : {
                    parentIdentity: this.context.getObjectIdentity()
                }
            });
            if (this.collapsed) {
                this.getCommentCounts();
                this.needReload = true;
            }
            else
                this.commentGrid.loadData();
        }
        else
            this.getCommentCounts();
    }

})();
/* EntryForm.js */

(function() {
    function getBindingForField(f) {
        if (f.portlet && f.portlet.ownerCt && f.portlet.ownerCt.bindings && f.portlet.ownerCt.bindings.length) {
            return f.portlet.ownerCt.bindings[0];
        }
        return null;
    }
    
    kw.widget.datatable.EntryForm = function(config) {
        kw.widget.datatable.EntryForm.superclass.constructor.call(this, null, config);
    }
    Ext.extend(kw.widget.datatable.EntryForm, Ext.form.BasicForm, {
        setMode: function(mode, bTransferValue) {
            for (var i=0, len=this.items.getCount(); i < len; ++i) {
                var f = this.items.itemAt(i);
                f.setMode(mode, bTransferValue);
            }
        },

        loadDefaultValues: function() {
            var record = {};
            for (var i=0, len=this.items.getCount(); i < len; ++i) {
                var f = this.items.itemAt(i);
                var dv = (f.loadDefaultValue) ? f.loadDefaultValue() : f._defaultValue;
                if (dv)
                    f.setValue(dv)
                record[f._fieldId]  = dv || null;
            }
            return record;
        },

        findFieldByTitle: function(t) {
            for (var i=0, len=this.items.getCount(); i < len; ++i) {
                var f = this.items.itemAt(i);
                if (f.portlet.widgetTitle == t)
                    return f;
            }
            return null;
        },

        onBeforeXulGeneration: function() {
            // move value to config param  _defaultValue (for schema page edit) 
            for (var i=0, len=this.items.getCount(); i < len; ++i) {
                var f = this.items.itemAt(i);
                var b = getBindingForField(f);
                if (b)
                {
                    var valParam = {_fieldId: f.dataIndex};
                    var defaultValue = (f.getDefaultConfigValueForXul) ? f.getDefaultConfigValueForXul() : { _defaultValue: f.getValue() };
                    Ext.apply(valParam, defaultValue);
                    b.saveConfigParams(valParam);
                }
            }
        },

        onCancelEdit: function() {
            for (var i=0, len=this.items.getCount(); i < len; ++i) {
                var f = this.items.itemAt(i);
                f.onCancelEdit();
            }
        },

        getTitleField: function() {
            for (var i=0, len=this.items.getCount(); i < len; ++i) {
                var f = this.items.itemAt(i);
                if (f.isTitleField)
                    return f;
            }
            return null;
        },

        removeDestroyedItems: function() {
            var dlist = [];
            for (var i=0, len=this.items.getCount(); i < len; ++i) {
                var f = this.items.itemAt(i);
                if (f.isDestroyed)
                    dlist.push(f);
            }
            for (i=0; i < dlist.length; ++i)
                this.items.remove(dlist[i]);
        }
    });
})();

/*
 * Copyright (c) 2010 EMC Corporation. All Rights Reserved.
 */

// kw.bubble.entryPreviewBubbleListContainer

Ext.namespace("kw.bubble");

rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib", "js/entryPreviewBubbleListWidget.js");
kw.ScriptLoader.require("js/kw/bubble/previewBubbleListTitle.js");
kw.ScriptLoader.require("js/kw/bubble/previewBubbleSysContent.js");

kw.bubble.entryPreviewBubbleListContainer = function(config){
    if (typeof config=="undefined") config = {};
    var thisConfig = {
        autoHeight : false,
		autoWidth : false,
        layout : 'border',
		cls : 'kw-bubble',
        border : false,
		bodyBorder : false,
		hideBorders : true,
        style: 'margin-left:4px',
        defaults: {
        },
        items : [new kw.bubble.entryPreviewBubbleListWidget({
                region: 'west',
                width: 220
		    }), new kw.bubble.previewBubbleSysContent({
                region: 'center',
                bodyStyle: 'padding-top:6px'
        })]
    }
    Ext.apply(thisConfig, config);
    kw.bubble.entryPreviewBubbleListContainer.superclass.constructor.call(this, thisConfig);
};

Ext.extend(kw.bubble.entryPreviewBubbleListContainer, Ext.Panel, {
});

Ext.reg("kwentrypreviewbubblelistcontainer", kw.bubble.entryPreviewBubbleListContainer);

// entryPreviewBubbleListWidget.js
/*
 * Copyright (c) 2010 EMC Corporation. All Rights Reserved.
 */

rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/DataTableColumnModel.js");

Ext.namespace("kw.bubble");

kw.bubble.entryPreviewBubbleListWidget = function(config)
{
    this.actionArgs = kw.bubble.getActionArgs();

    var _actionArgs = this.actionArgs;
    var _context = _actionArgs.context;
    var _metadata = _actionArgs.selection.items[0].metadata;
    var metaType = _metadata.getMetaType();

    var store = new kw.data.Store({
        proxy:     new kw.data.DWRProxy(ListService.fetchResults),
        reader:    new kw.data.ServiceResultsReader(),
        remoteSort: true,
        grid: this
    });
    var filter = new FilterInfo();
    filter.parameters = [{
        name: kw.bubble.metaTypes[metaType].filter_parameterName,
        value: _metadata.get("r_object_id")
    }];

    var queryId = kw.bubble.metaTypes[metaType].queryId;
    var loadParams = {serviceMethodParams : new Object({
                     listQuery: {datalistId: queryId,
                                 repositories: [_context.repository],
                                 context:kw.Util.getListQueryContainerContext(_metadata.get("r_object_id"))
                     },
                     filter:filter, sorting: null})};

    var thisConfig =
    {
        context: _context,
        store:   store,
        storeLoadParams: loadParams,
        autoHeight: false,
        width: 220,
        height: 145,
        viewConfig: {
            forceFit: true
        }
    };
    Ext.apply(thisConfig, config);

    Ext.applyIf(thisConfig, {
        loadMask:   true,
        hideHeaders: true,
        cm:         new Ext.grid.ColumnModel( [{header: "item", renderer: this.columnRenderer}])
//        cm: new kw.widget.datatable.DataTableColumnModel()
    });
    
    kw.bubble.entryPreviewBubbleListWidget.superclass.constructor.call(this, thisConfig);
};

Ext.extend(kw.bubble.entryPreviewBubbleListWidget, Ext.grid.GridPanel,
{
    columnRenderer: function( value, metadata, record, rowIndex, colIndex, store)
    {
        var _data = record.data;
        var objName = _data.object_name;
        var _fields = record.fields;
        var entryDetails = "<div class='kw-dt-entry-container'>";
        var metrics = Ext.util.TextMetrics.createInstance(store.grid.el);

        var fieldTpl = "<div class='kw-dt-entry-column-label'>{0}</div><br><div class='kw-dt-entry-column-value'>{1}</div>";
        var colLblWidth = Ext.isIE ? 163 : 170;

        for (var i=0; i < _fields.length; i++){
            var column = Ext.util.Format.substr(_fields.items[i].name, 0, 7);
            if (column === 'column_'){
                var columnlabel = kw.Util.ellipsisByPixelWidth(metrics, _fields.items[i].label, colLblWidth, '...');
                var columnValue = record.data[_fields.items[i].name];

                if ((_fields.items[i].renderType == 'cma.kw.form.RichText') || (_fields.items[i].type == 'com.emc.documentum.fs.datamodel.core.RichText') ){
                    if (typeof(columnValue) == 'string')
                        columnValue = Ext.util.Format.stripTags(columnValue);
                    else
                        columnValue = Ext.util.Format.stripTags(columnValue.bodyAsString);

					if (columnValue.length > 500){
                        columnValue = Ext.util.Format.ellipsis(columnValue, 500);
                    }
				}
                //KWC-8178
                else if (_fields.items[i].renderType == 'cma.kw.form.YesNoField') {
                    switch (columnValue) {
                        case (' ' || 0): columnValue = ' '; break;
                        case ('No' || 1): columnValue = kw.Strings.btnNo; break;
                        case ('Yes' || 2): columnValue = kw.Strings.btnYes; break;
                    }
                }
                //kwc-8729
                else if (_fields.items[i].renderType == 'cma.kw.form.TrafficLight') {
                        if(columnValue && columnValue.smIconUrl) {
                            var iconUrl = columnValue.smIconUrl;
                            columnValue = "<img class='traffic-light-image' src='" + iconUrl + "'/>";
                        }
                        else  {
                            columnValue = "";
                        }
                }

                else if(_fields.items[i].renderType == 'cma.kw.form.MemberList' || _fields.items[i].type == 'com.emc.documentum.kw.datamodel.application.Member' ){
                    columnlabel = kw.Util.ellipsisByPixelWidth(metrics, _fields.items[i].label, colLblWidth-8, '...');
                    var names = [];
                    if (Ext.isArray(columnValue))
                    {
                        var name, props;
                        for (var j = 0; j < columnValue.length; j++)
                        {
                            if (Ext.isObject(columnValue[j]))
                            {
                                props = columnValue[j].properties;
                                names.push((props.group_display_name) ? props.group_display_name : props.user_name);
                            }
                        }
                    }else if(columnValue){
                        props = columnValue.properties;
                        names.push((props.group_display_name) ? props.group_display_name : props.user_name);
                    }
                    columnValue = Ext.util.Format.htmlEncode(names.join("; "));
                }
                else if(_fields.items[i].renderType == 'cma.kw.form.ChoiceList'){
                    if (Ext.isArray(columnValue))
                        columnValue = Ext.util.Format.htmlEncode(columnValue.join(", "));
                    else {
                        columnValue = Ext.util.Format.htmlEncode(columnValue);
                    }
                }
                else if(_fields.items[i].renderType == 'cma.kw.form.Lifecycle'){
                        columnValue = Ext.util.Format.htmlEncode(columnValue.value.currentStateName); 
                }
                else if(_fields.items[i].renderType == 'cma.kw.form.DateField'){
                    if (columnValue.dueDate)
                        columnValue = Ext.util.Format.htmlEncode(columnValue.dueDate);
                    else
                        columnValue = Ext.util.Format.htmlEncode(columnValue);
                }
                else
                    columnValue = Ext.util.Format.htmlEncode(columnValue);

                entryDetails += String.format(fieldTpl, columnlabel+":", columnValue);
            }
        }
        entryDetails += "</div>";
        return entryDetails;
    },

    onLoadData : function(records,options,success)
    {
        var foo; //for debugging
    },

    loadData : function()
    {
        this.store.load({params: this.storeLoadParams});
    },

    render : function()
    {
        kw.bubble.entryPreviewBubbleListWidget.superclass.render.apply(this, arguments);
        var bubble = Ext.getCmp(this.el.findParent(".x-tip").id);
        bubble.on("show", this.view.layout, this.view);
        this.loadData();
    },

    afterRender : function(){ // kwc-5431
        Ext.grid.GridPanel.superclass.afterRender.call(this);
        this.view.layout();
        if(this.deferRowRender){
            (function() {
                if (this.ds) {
                    this.afterRender();
                }
            }).createDelegate(this).defer(10, this.view);

        }else{
            this.view.afterRender();
        }
        this.viewReady = true;
    }
});

// EntryTagEditor.js

Ext.namespace("kw.widget.datatable");

kw.ScriptLoader.require("js/kw/widget/TagEditor.js");

(function() {
    kw.widget.datatable.EntryTagEditor = Ext.extend(kw.widget.TagEditor, {
        onRender: function() {
            kw.widget.datatable.EntryTagEditor.superclass.onRender.apply(this, arguments);
            this.rowControl = kw.widget.datatable.getRowControlForWidget(this);
            this.rowControl.on("contextchanged", onContextChanged, this);
        },

        beforeDestroy: function() {
            if (this.rowControl)
                this.rowControl.un("contextchanged", onContextChanged, this);
            
            kw.widget.datatable.EntryTagEditor.superclass.beforeDestroy.call(this);
        }        
    });

    function onContextChanged() {
        this.initFromContext();
        this.removeAll();
        this.getContentTags();
    }

})();

Ext.reg('kwentrytageditor', kw.widget.datatable.EntryTagEditor);
/* FieldSettings.js */

kw.ScriptLoader.require('js/kw/widget/form/Multiselect.js');
kw.ScriptLoader.require("js/kw/widget/form/FieldPlugIn.js");
kw.ScriptLoader.requireStrings("Datatable");

Ext.namespace("kw.widget.FieldSettings");

(function() {

kw.widget.FieldSettings.FieldList = Ext.extend(Ext.Panel,
{
    constructor: function(config)
    {
        this.addEvents('rightarrow', 'leftarrow', 'enable_leftarrow', 'diable_leftarrow');

        var helpTextOffset = (config.hasCaptionHelpText) ? 10 : 0;

        this.msCfg =
        {
            x: 45,
            y: 20 + helpTextOffset,
            height: 89,
            width: 180,
            multiSelect: true,
            allowEmpty: config.allowEmpty,
            dataFields: config.dataFields,
            data: config.data,
            valueField: config.valueField,
            displayField: config.displayField,
            listeners: {dblclick: {fn: this.onDblClick, scope: this}, change: {fn: this.onChange, scope: this}}
        };

        this.multiSel = new Ext.ux.Multiselect(this.msCfg);

        this.rightBtn = new Ext.Button({icon: kw.ScriptLoader.getImagePath() + 'emc-ext/button/select.png',
                                        listeners: {click: {fn: this.onRight, scope: this}},
                                        template: '',
                                        autoWidth: true,
                                        autoHeight: true});

        this.leftBtn = new Ext.Button({icon: kw.ScriptLoader.getImagePath() + 'emc-ext/button/deselect.png',
                                       listeners: {click: {fn: this.onLeft, scope: this}},
                                       template: '',
                                       autoWidth: true,
                                       autoHeight: true});

        var toolButtonCls = 'kw-dt-fieldsettings-button';

        Ext.apply(config,
        {
            cls: 'kw-fieldlist',
            layout: 'absolute',
            height: 111 + helpTextOffset,
            width: 400,
            defaults: {forceLayout:true},  // Ext 3.1
            items:
            [
                config.caption,
                this.multiSel,
                {xtype: 'toolbar', cls: toolButtonCls, x: 0, y: 30+helpTextOffset, items: [this.rightBtn]},
                {xtype: 'toolbar', cls: toolButtonCls, x: 0, y: 60+helpTextOffset, items: [this.leftBtn]}
            ]
        });

        if (config.allowReorder)
        {
            this.upBtn = new Ext.Button({icon: kw.ScriptLoader.getImagePath() + 'emc-ext/button/move_up.png',
                                         listeners: {click: {fn: this.onUp, scope: this}}});
            this.dnBtn = new Ext.Button({icon: kw.ScriptLoader.getImagePath() + 'emc-ext/button/move_down.png',
                                         listeners: {click: {fn: this.onDown, scope: this}}});
            config.items.push({xtype: 'toolbar', cls: toolButtonCls, x:230, y:42+helpTextOffset, items: [this.upBtn]},
                              {xtype: 'toolbar', cls: toolButtonCls, x:230, y:72+helpTextOffset, items: [this.dnBtn]});
        }

        kw.widget.FieldSettings.FieldList.superclass.constructor.call(this, config);
    },

    getList: function(field)
    {
        var raw = this.multiSel.store.getRange();
        var list = [];
        var vf = this.msCfg.valueField;
        var df = this.msCfg.displayField;
        for (var i=0; i < raw.length; ++i)
        {
            list[i] = [];
            if (!field)
                list[i].push(raw[i].data[df], raw[i].data[vf]);
            else if (field == df)
                list[i].push(raw[i].data[df]);
            else if (field == vf)
                list[i].push(raw[i].data[vf]);
        }
        return list;
    },

    setList: function(records)
    {
        this.multiSel.store.loadData(records);
    },

    addToList: function(record)
    {
        var vf = this.msCfg.valueField;
        if (this.multiSel.store.find(vf,record.data[vf]) == -1)
        {
            this.multiSel.store.add([record]);
        }
    },

    getSelected: function()
    {
        return this.multiSel.getValue().split(',');
    },

    onRight: function()
    {
        this.fireEvent('rightarrow');
    },

    onLeft: function()
    {
        this.fireEvent('leftarrow');
    },

    onDblClick: function(multiSel, index, elem, evt)
    {
        var l = this.getList();
        var min_length = (this.allowEmpty) ? 0 : 1;
        if (l.length > min_length)
        {
            this.multiSel.setValue(l[index][1]);
            this.fireEvent('leftarrow');
        }
    },

    onChange: function(multiSel, newValue, oldValue)
    {
        var values = newValue.split(',');
        if (values.length == 0)
        {
            this.fireEvent('enable_leftarrow');
            return;
        }

        var titleColumnId = this.dtOptions.getTitleColumnId();

        var titleColumnIdInNewValues = false;
        for (var i = 0; i < values.length; i++)
        {
            if (values[i] == titleColumnId)
            {                
                titleColumnIdInNewValues = true;
                break;
            }
        }

        values = oldValue.split(',');
        var titleColumnIdInOldValues = false;
        for (var j = 0; j < values.length; j++)
        {
            if (values[j] == titleColumnId)
            {                
                titleColumnIdInOldValues = true;
                break;
            }
        }

        if (titleColumnIdInNewValues)
            this.fireEvent('disable_leftarrow');
        else
        if (titleColumnIdInOldValues)
            this.fireEvent('enable_leftarrow');
    },

    onUp: function()
    {
        var sel = this.multiSel.getValue().split(',');
        if (sel.length == 0) return;

        var list = this.getList();
        var selOrd = [];
        var extract = [];
        for (var i=0; i < sel.length; ++i)
        {
            var v = sel[i];
            for (var j=1; j < list.length; ++j)
            {
                if (v == list[j][1])
                {
                    extract.push(list[j]);
                    selOrd.push(j);
                    break;
                }
            }
        }

        selOrd.sort(function(a,b) {return ((a==b)?0:((a>b)?1:-1));});

        for (i=selOrd.length-1; i >=0; --i)
            list.splice(selOrd[i], 1);

        for (i=0; i < extract.length; ++i)
            list.splice(selOrd[0]-1 + i , 0, extract[i]);

        this.multiSel.store.loadData(list);
        this.multiSel.setValue(sel.join(','));
    },

    onDown: function()
    {
        var sel = this.multiSel.getValue().split(',');
        if (sel.length == 0) return;

        var list = this.getList();
        var selOrd = [];
        var extract = [];
        for (var i=0; i < sel.length; ++i)
        {
            var v = sel[i];
            for (var j=0; j < list.length-1; ++j)
            {
                if (v == list[j][1])
                {
                    extract.push(list[j]);
                    selOrd.push(j);
                    break;
                }
            }
        }

        selOrd.sort(function(a,b) {return ((a==b)?0:((a>b)?1:-1));});

        for (i=selOrd.length-1; i >=0; --i)
            list.splice(selOrd[i], 1);

        var targetPos = selOrd[selOrd.length-1]+2-selOrd.length;
        for (i=0; i < extract.length; ++i)
            list.splice(targetPos + i , 0, extract[i]);

        this.multiSel.store.loadData(list);
        this.multiSel.setValue(sel.join(','));
    }
});

// --------------------------------------------------------------------

kw.widget.FieldSettings.Panel = Ext.extend(Ext.Panel,
{
    constructor: function(config)
    {
        this.master = new Ext.ux.Multiselect(
        {
            x: 0,
            y: 0,
            width: 180,
            height: 250,
            multiSelect: true,
            dataFields: ['name', 'fid'],
            data: config.data,
            valueField: 'fid',
            displayField: 'name'
        });

        var entriesCaption = String.format('<div>{0}<br/><span class="kwhelp">{1}</span></div>',
                                           kw.Strings.Datatable.summaryFieldListCaption,
                                           kw.Strings.Datatable.summaryFieldListHelp);

        var entriesCfg = {x: 200,
                          y: 0,
                          hasCaptionHelpText: true,
                          caption: {x: 45, y: 0, html: entriesCaption},
                          allowEmpty: false,
                          allowReorder: true};

        var filtersCfg = {x: 200,
                          y: 139,
                          hasCaptionHelpText: false,
                          caption: {x: 45, y: 0, html: kw.Strings.Datatable.filterFieldListCaption},
                          allowEmpty: true,
                          allowReorder: false};

        var commonCfg =
        {
            dataFields: ['name', 'fid'],
            data: [],
            valueField: 'fid',
            displayField: 'name',
            dtOptions: config.dtOptions
        };

        Ext.apply(entriesCfg, commonCfg);
        Ext.apply(filtersCfg, commonCfg);

        this.entries = new kw.widget.FieldSettings.FieldList(entriesCfg);
        this.filters = new kw.widget.FieldSettings.FieldList(filtersCfg);

        this.entries.on('enable_leftarrow', this.enableLeftArrow, this);
        this.entries.on('disable_leftarrow', this.disableLeftArrow, this);
        this.entries.on('rightarrow', this.addSelectedToEntries, this);
        this.entries.on('leftarrow', this.removeSelectedFromEntries, this);
        this.filters.on('rightarrow', this.addSelectedToFilters, this);
        this.filters.on('leftarrow', this.removeSelectedFromFilters, this);

        Ext.apply(config,
        {
            height: 260,
            width: 600,
            layout: 'absolute',
            cls: 'kw-fieldsettings',
            items: [this.master, this.entries, this.filters]
        });

        kw.widget.FieldSettings.Panel.superclass.constructor.call(this, config);
    },

    setUpKeyMaps: function()
    {
        addKeySupport.call(this.master);
        addKeySupport.call(this.entries.multiSel);
        addKeySupport.call(this.filters.multiSel);
    },

    setMainFieldList: function(records)
    {
        if (this.master.store)
            this.master.store.loadData(records);
        this.all = this.getList();
    },

    removeDeletedFromFieldList: function(fieldListPanel, allowEmpty)
    {
        var records = fieldListPanel.getList();
        if (!allowEmpty && records.length == 1)
            return;

        var id, deleted_ids = [];
        for (var r = 0; r < records.length; r++)
        {
            id = records[r][1];
            if (!this.lookup(id))
                deleted_ids.push(id);
        }
        if (deleted_ids.length == 0)
            return;

        records = this.clear(records, deleted_ids);
        fieldListPanel.setList(records);
    },

    updateFieldList: function(fieldListPanel)
    {
        var records = fieldListPanel.getList();
        var dv, id, mdv, master_record;
        var modified = false;
        for (var r = 0; r < records.length; r++)
        {
            var record = records[r];
            dv = record[0];
            id = record[1];
            master_record = this.lookup(id);
            if (master_record != null)
            {
                mdv = master_record[0];
                if (dv != mdv)
                {
                    record[0] = mdv;
                    modified = true;
                }
            }
        }

        if (modified)
            fieldListPanel.setList(records);
    },

    setEntriesList: function(records)
    {
        this.entries.setList(records);
        if (records.length <= 1)
            this.entries.leftBtn.disable();
        else
            this.entries.leftBtn.enable();
    },

    setFiltersList: function(records)
    {
        this.filters.setList(records);
    },

    getList: function()
    {
        var raw = this.master.store.getRange();
        var list = [];
        var vf = 'fid';
        var df = 'name';
        for (var i=0; i < raw.length; ++i)
        {
            list[i] = [];
            list[i].push(raw[i].data[df], raw[i].data[vf]);
        }
        return list;
    },

    addSelectedToEntries: function()
    {
        var master_selected = this.getMasterSelectValues();
        var master_store = this.master.store;

        selected = [];
        for (var i = 0; i < master_selected.length; i++)
        {
            var index = master_store.find('fid', master_selected[i]);
            if (index != -1)
            {
                var record = master_store.getAt(index);
                var attributes = record.json[4];
                if (attributes && attributes.isSummaryField)
                    selected.push(master_selected[i]);
            }
        }

        if (selected.length == 0)
            return;

        var recs = this.entries.getList().concat(this.generateRecordsFromSelection(selected));
        recs = this.dedup(recs);
        this.setEntriesList(recs);
    },

    enableLeftArrow: function()
    {
        this.entries.leftBtn.enable();
    },

    disableLeftArrow: function()
    {
        this.entries.leftBtn.disable();
    },

    removeSelectedFromEntries: function()
    {
        var list = this.entries.getList();
        if (list.length <= 1)
            return;

        var v = [];
        var titleColumnId = this.dtOptions.getTitleColumnId();
        var selectedEntries = this.entries.getSelected();
        for (var i = 0; i < selectedEntries.length; i++)
        {
            if (selectedEntries[i] != titleColumnId)
                v.push(selectedEntries[i]);
        }

        if (v.length < 1)
            return;

        list = this.clear(list, v);
        this.setEntriesList(list);
    },

    removeDeletedFromEntries: function()
    {
        this.removeDeletedFromFieldList(this.entries,false);
    },

    updateEntries: function()
    {
        this.updateFieldList(this.entries);
    },

    addSelectedToFilters: function()
    {
        var master_selected = this.getMasterSelectValues();
        var master_store = this.master.store;

        selected = [];
        for (var i = 0; i < master_selected.length; i++)
        {
            var index = master_store.find('fid', master_selected[i]);
            if (index != -1)
            {
                var record = master_store.getAt(index);
                var attributes = record.json[4];
                if (attributes && attributes.isSearchable)
                    selected.push(master_selected[i]);
            }
        }

        if (selected.length == 0)
            return;

        var recs = this.filters.getList().concat(this.generateRecordsFromSelection(selected));
        recs = this.dedup(recs);
        this.filters.setList(recs);
    },

    removeSelectedFromFilters: function()
    {
        var v = this.filters.getSelected();
        var list = this.filters.getList();
        list = this.clear(list, v);
        this.filters.setList(list);
    },

    removeDeletedFromFilters: function()
    {
        this.removeDeletedFromFieldList(this.filters, true);
    },

    updateFilters: function()
    {
        this.updateFieldList(this.filters);
    },

    getMasterSelectValues: function()
    {
        return this.master.getValue().split(',');
    },

    lookup: function(val)
    {
        if (!this.all)
            this.all = this.getList();

        for (var i=0; i < this.all.length; ++i)
        {
            if (this.all[i][1] == val)
                return this.all[i];
        }
        return null;
    },

    generateRecordsFromSelection: function(selected)
    {
        var recs = [];
        for (var i=0; i < selected.length; ++i)
        {
            var r = this.lookup(selected[i]);
            if (r)
                recs.push(r);
        }
        return recs;
    },

    dedup: function(recs)  // must preserve order
    {
        var result =[];
        for (var i=0; i < recs.length; ++i)
        {
            var v = recs[i][1];
            var inResult = false;
            for (var j=0; j < result.length; ++j)
            {
                if (result[j][1] == v)
                {
                    inResult = true;
                    break;
                }
            }

            if (!inResult)
                result.push(recs[i]);
        }

        return result;
    },

    clear: function(recs, sel)
    {
        var result = [];
        for (var i=0; i < recs.length; ++i)
        {
            var v = recs[i][1];
            var add = true;
            for (var j=0; j < sel.length; ++j)
            {
                if (v == sel[j])
                {
                    add = false;
                    break;
                }
            }
            if (add)
                result.push(recs[i]);
        }
        return result;
    }
});

function addKeySupport()  // incomplete!
{
    var keyMap = new Ext.KeyMap(this.view.getEl(),
    [{
        key: [Ext.EventObject.SPACE],
        fn: onSpace,
        scope: this
    },
    {
        key: [Ext.EventObject.DOWN],
        fn: onDown,
        scope: this
    },
    {
        key: [Ext.EventObject.UP],
        fn: onUp,
        scope: this
    }]);
}

function onSpace(key, e)
{
    e.stopEvent();
    var target = e.getTarget();
    var viewIndex = target.viewIndex;
    if (typeof viewIndex != 'undefined')
    {
        if (this.isSelected(viewIndex))
        {
            if (e.ctrlKey)
                this.deselect(viewIndex);
        }
        else
        {
            this.select(viewIndex, true);
        }
    }
}

function onDown()
{
    alert('down ' + this.id);
}

function onUp()
{
    alert('up ' + this.id);
}

})();

// MemberSearchField.js
/*
 * Copyright (c) 2010 EMC Corporation. All Rights Reserved.
 */

(function() {
    kw.ScriptLoader.require("js/kw/widget/form/MemberField.js");
    kw.ScriptLoader.require("js/kw/widget/form/FieldPlugIn.js");

    var pkg = rcmp.packageFromPath("cma.kw.form", true);
    
    pkg.MemberSearchField = function(config) {
        pkg.MemberSearchField.superclass.constructor.call(this, config);
        rcmp.intf.attachInterfaces(this, pkg.MemberSearchField);
    };

    Ext.extend(pkg.MemberSearchField, Ext.form.Field, {
        defaultAutoCreate : {tag: "div"},
        defaultOption: "UNDEFINED",

        onRender: function(ct, pos) {
            pkg.MemberSearchField.superclass.onRender.apply(this, arguments);
            addMemberPicker.call(this);
            this.setSearchFilter(this.initialConfig.searchExpression);
        },

        getSearchExpressions: function() {
            var memberNameArray = getSelection.call(this);
            if (memberNameArray.length == 0)
                return null;

            var expr = new PropertyExpression();
            expr.property = this.dtFieldInfo.columnName;
            expr.condition = "IN";
            expr.value = new ValueList();
            expr.value.values = memberNameArray;
            return expr;
        },

        setSearchFilter:function(expr) {
            if (!expr)
                this.resetSearchFilter();
            else if (typeof expr.condition !== "undefined") {                
                this.picker.setValueFromMemberNameArray(expr.value.values);
            }
            else
                kw.Util.debugHere("unexpected");
            return expr;
        },

        resetSearchFilter: function() {
            this.picker.clearValue();
        }
    });

    function addMemberPicker() {
        var ctx = this.findParentBy(function(c) {
            return c.context;
        }).context;
        this.picker = new kw.widget.form.MemberField({
            renderTo: this.el,
            name: 'pick' + this.dtFieldInfo.columnName,
            ctCls : 'kw-member-search-picker',
            required:false,
            plugins: new kw.widget.FieldPlugIn(),
            labelSeparator: '',
            anchor: kw.Dialog.defaults.anchor,
            actionArgs: new kw.ActionArgs({context: ctx}),
            allowMultiple:true,
            pickerOptions: {enableAllSpaceMembers: true, includeOnlySpaceUsers: true},            
            triggerHandler: onPickerClick.createDelegate(this)
        });
    }
    
    function onPickerClick() {
        kw.widget.form.MemberField.prototype.onTriggerClick.call(this.picker);
    }

    function getSelection() {
        return this.picker ? this.picker.getValueAsMemberNameArray() || [] : [];
    }

    rcmp.intf.implementInterface(pkg.MemberSearchField, "kw.component.IDtSearchField");
    Ext.reg("membersearchfield", pkg.MemberSearchField);
})();

// NumberSearchField.js

var pkg = rcmp.packageFromPath("cma.kw.form", true);

pkg.NumberSearchField = function(config) {
    pkg.NumberSearchField.superclass.constructor.call(this, config);
    rcmp.intf.attachInterfaces(this, pkg.NumberSearchField);

    if (!pkg.NumberSearchField.searchOperatorNls) {
        var searchOperators = ["EQUAL", "GREATER_THAN", "LESS_THAN", "GREATER_EQUAL",
                        "LESS_EQUAL", "NOT_EQUAL", "BETWEEN"];

        pkg.NumberSearchField.searchOperatorNls = {};
        kw.RcmpBinding.getNlsStrings("cma.kw.form.NumberField", searchOperators, pkg.NumberSearchField.searchOperatorNls);
    }
}

Ext.extend(pkg.NumberSearchField, Ext.form.Field,{
    defaultAutoCreate: {
        tag: 'div'
    },

    defaultSearchOperator: "EQUAL",

    onRender : function(ct, position){
        pkg.NumberSearchField.superclass.onRender.call(this, ct, position);

        var select = "<select>";
        for (var nlsId in pkg.NumberSearchField.searchOperatorNls) {
            select += "<option value=\"" + nlsId + "\">" + pkg.NumberSearchField.searchOperatorNls[nlsId] + "</option>";
        }
        select += "</select>"

        var searchOperator = Ext.DomHelper.insertHtml("afterBegin", this.el.dom,
                select +
                "&nbsp<input type='text' class='kw-dt-number-search-value1' autocomplete='off' size='4'/>" +
                "&nbsp<em class='kw-dt-search-between-dash'>-</em>" +
                "&nbsp<input type='text' class='kw-dt-number-search-value2' autocomplete='off' size='4'/>");

        this.searchOperator = Ext.get(searchOperator);
        this.searchOperator.on("change", this.onSearchOperatorChange, this);
        this.searchVal1 = this.el.child('.kw-dt-number-search-value1')
        this.dash = this.el.child('.kw-dt-search-between-dash');
        this.searchVal2 = this.el.child('.kw-dt-number-search-value2');

        var iDtSearchField = rcmp.intf.getInterface(this, "kw.component.IDtSearchField");
        iDtSearchField.setSearchFilter(this.searchExpression);        
    },

    onSearchOperatorChange: function() {
        if (this.searchOperator.getValue() == "BETWEEN") {
            this.dash.show();
            this.searchVal2.show();
        }
        else {
            this.dash.hide();
            this.searchVal2.hide();
        }
    },

    getSearchExpressions: function() {
        var value = this.searchVal1.dom.value;
        if (!Ext.isEmpty(value)) {
            var propExp = new PropertyExpression();
            propExp.property = this.dtFieldInfo.columnName;
            propExp.condition = this.searchOperator.dom.value;
            propExp.dataType = "DOUBLE";
            if (propExp.condition != "BETWEEN") {
                propExp.value = new SimpleValue();
                propExp.value.value = this.searchVal1.dom.value;
            }
            else {
                propExp.value = new RangeValue();
                propExp.value.fromValue = this.searchVal1.dom.value;
                propExp.value.toValue = this.searchVal2.dom.value;
            }
            return propExp;
        }

        return null;
    },

    setSearchFilter:function(searchExpression) {
        if (!searchExpression)
            this.resetSearchFilter();
        else {
            this.searchOperator.dom.value = searchExpression.condition;
            if (searchExpression.condition != "BETWEEN") {
                this.searchVal1.dom.value = searchExpression.value.value;
                this.dash.hide();
                this.searchVal2.hide();
            } else {
                this.searchVal1.dom.value = searchExpression.value.fromValue;
                this.searchVal2.dom.value = searchExpression.value.toValue;
            }
        }
    },

    resetSearchFilter: function() {
        this.searchOperator.dom.value = this.defaultSearchOperator;
        this.searchVal1.dom.value = "";
        this.dash.hide();
        this.searchVal2.hide();
        this.searchVal2.dom.value = "";
    }
});

rcmp.intf.implementInterface(pkg.NumberSearchField, "kw.component.IDtSearchField");

Ext.reg("numbersearchfield", pkg.NumberSearchField);
/* RowControl.js */

Ext.namespace("kw.widget.datatable");

rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/EntryForm.js");
rcmp.resource.SharedLibraryResourceLoader.loadJS("cma.kw.datatable.sharedlib","js/DtWidget.js");

(function() {

kw.widget.datatable.RowControl = function(config) {
 if (kw.Util.getDebugMode()) kw._rc = this; // handy for debugging
    this.addEvents("rowmodified");
    rcmp.intf.attachInterfaces(this, kw.widget.datatable.RowControl);
    this.subscriptions = [];
    this.parent = config.parent;
    this.parent.on("destroy", this.onParentDestroy, this);
    this.form = new kw.widget.datatable.EntryForm({});
    this.titleColumn = '';
    this.schemaHasAttachmentField = false; // attachments widget will set to true

    this.state = {
        _isSchemaPage: config.isSchemaPage,
        _mode: config.isSchemaPage ? kw.widget.datatable.SCHEMA_MODE : kw.widget.datatable.VIEW_MODE,
        _isNewEntry: false,
        _recInStore: false
    };

    // If the user navigates to the entry page from the summary grid,
    // we pass along the grid store in context.navData.store for
    // next/previous actions to use.
    var node = document.getElementById(config._kw_ctxElementId);
    var tab = kw.RendEng.getTabManager().findTabComponentForNode(node);
    if (tab.fullContext.navData) this.dtStore = tab.fullContext.navData.store;
    if (this.dtStore) {
        this.dtStore.proxy.purgeListeners();

        var savedDestroyListeners = [];
        if (this.dtStore.events.beforedestroy.listeners) {
            var n = this.dtStore.events.beforedestroy.listeners.length;
            for (var i=0; i < n; ++i) {
                savedDestroyListeners.push(Ext.apply({}, this.dtStore.events.beforedestroy.listeners[i]));
            }
        }
        this.dtStore.purgeListeners();

        if (savedDestroyListeners.length) {
            Ext.each(savedDestroyListeners, function(listener) {
                this.dtStore.on("beforedestroy", listener.fn, listener.scope);
            }, this);
        }

        function pred(rec, id) {
            return rec.data.r_object_id == this.fullContext.id;
        }
        this.state._recIdx = this.dtStore.findBy(pred, tab);
        this.record = this.dtStore.getAt(this.state._recIdx);
        this.state._recInStore = true;
    }

    kw.widget.datatable.RowControl.superclass.constructor.call(this, {});
};

Ext.extend(kw.widget.datatable.RowControl, Ext.Component, {
    preNavigate:function(rowContext){
        if (this.dtStore)
            rowContext.navData = {store: this.dtStore};
    },
    beforeDestroy: function() {
        var myTab = kw.RendEng.tabManager.findTabComponentForNode(this.pageControl.box.el.dom);
        if (myTab){
            myTab.un("navigate", onNavigateAway, this);
            myTab.un("mybeforeclose", onTabClose, this);
            kw.RendEng.getTabManager().un("savetabstate", onSaveTabState, this);
        }

        Ext.each(this.subscriptions, kw.Events.unsubscribe);
        this.constructor.superclass.beforeDestroy.call(this);     // dlm todo ?????
    },
    getMode: function() {
        return this.state._mode;
    },
    isSchemaPage: function() {
        return this.state._isSchemaPage;
    },
    isNewEntry: function() {
        return this.state._isNewEntry;
    },

    isPreviousBtnDisabled: function() {
        var execOptions = this.dtStore.lastOptions.params.serviceMethodParams.filter.execOptions;
        if (execOptions.startingIndex == 0 && this.state._recIdx == 0)
            return true;
        return false;
    },

    displayPreviousEntry: function() {
        var execOptions = this.dtStore.lastOptions.params.serviceMethodParams.filter.execOptions;
        if (this.isPreviousBtnDisabled())
            return;
        var pageSize = execOptions.maxResultCount;
        if (this.state._recIdx >0)
            this.updateForNextPrevious(this.state._recIdx-1);
        else {
            execOptions.startingIndex -= execOptions.maxResultCount;
            this.dtStore.on("load", function() {
                kw.Progress.EndProgress(this);
                
                this.adjustSavedGridPage();

                this.updateForNextPrevious(pageSize-1);
            }, this, {single:true});
            kw.Progress.ShowProgress(this);
            this.dtStore.reload();
        }
    },

    isNextBtnDisabled: function() {
        var execOptions = this.dtStore.lastOptions.params.serviceMethodParams.filter.execOptions;
        if (execOptions.startingIndex + this.state._recIdx == this.dtStore.totalLength-1)
            return true;
        return false;
    },

    displayNextEntry: function() {
        var execOptions = this.dtStore.lastOptions.params.serviceMethodParams.filter.execOptions;
        if (this.isNextBtnDisabled())
            return;
        var pageSize = execOptions.maxResultCount;
        if (this.state._recIdx < pageSize-1)
            this.updateForNextPrevious(this.state._recIdx+1);
        else {
            execOptions.startingIndex += execOptions.maxResultCount;
            this.dtStore.on("load", function() {
                kw.Progress.EndProgress(this);

                this.adjustSavedGridPage();

                this.updateForNextPrevious(0);
            }, this, {single:true});
            kw.Progress.ShowProgress(this);
            this.dtStore.reload();
        }
    },

    getNameOfNextOrPrevEntry: function(bNext) { // for tooltip
        if (!this.dtStore)
            return "";

        if ((bNext && this.isNextBtnDisabled()) || (!bNext && this.isPreviousBtnDisabled()))
            return "";

        var execOptions = this.dtStore.lastOptions.params.serviceMethodParams.filter.execOptions;
        var pageSize = execOptions.maxResultCount;
        var idx;

        if (bNext) {
            idx = this.state._recIdx + 1;
            if (idx >= pageSize)
                return "";
        }
        else {
            idx = this.state._recIdx - 1;
            if (idx < 0)
                return "";
        }

        var record = this.dtStore.getAt(idx);
        var name = record.data[this.getTitleColumn()];
        if (name && name.bodyAsString) {
            name = String.escape(Ext.util.Format.stripTags(name.bodyAsString));
            name = Ext.util.Format.htmlDecode(name.replace(/&nbsp;/g, ' ')).trim();
            name = name.replace(/\\'/g, "&apos;");
        }
        else
            name = Ext.util.Format.htmlEncode(name);
        
        return name;
    },

    updateForNextPrevious: function(idx) {
        this.record = this.dtStore.getAt(idx);
        this.state._recInStore = true;
        this.state._recIdx = idx;
        this.form.loadRecord(this.record);

        this.record.data.i_folder_id =  this.context.getContextProperties().get("i_folder_id");
        this.context.setContextProperties(this.record, {updateRawProperties: true});
        var contextNode = kw.RendEng.findContextNode(kw.RendEng.URI_ELEM_PAGE, this.el.dom);
        contextNode.getAttributeNode('_kw_page').nodeValue = this.record.data.r_object_id;
        kw.HashWatcher.adjustLocation(this.context.getUrl());
        var tab = kw.RendEng.getTabManager(true).getActiveTab();
        tab.fullContext.setContextProperties(this.record, {updateRawProperties: true});

        var scrollRegion = Ext.DomQuery.selectNode(".kw-dtentry-content", contextNode);
        if (scrollRegion) {
            Ext.get(scrollRegion).scrollTo("top", 0, false);
        }

        var viewcontrol=kw.widget.ViewControl.getViewControlFromNode(this.el.dom);
        var breadcrumbs;
        if (viewcontrol)
            breadcrumbs=viewcontrol.getBreadcrumbs();
        if (breadcrumbs) {
            // we didn't navigate so last crumb needs an update.
            breadcrumbs.loadLastCrumb(this.record);
//            var crumbs = breadcrumbs.getBreadcrumbsData();
//            var crumb=crumbs[crumbs.length-1];
//            crumb.id.id=this.record.get("r_object_id");
//            crumb.objectName=this.record.get("object_name");
        }
        this.fireEvent("loadrecord", this.record);

        // Delay the DWR batch call if the user is clicking through the
        // list of entries really fast.  We want to make the DWR batch
        // call when the user stops clicking on the Next/Previous buttons.
        if (!this.delayUpdateWidgets)
            this.delayUpdateWidgets = new Ext.util.DelayedTask(function() {
                dwr.engine.beginBatch();
                this.fireEvent("contextchanged");
                dwr.engine.endBatch();
                this.fireEvent("updateemailaddr");
                var scroller = Ext.DomQuery.selectNode(".kw-dtentry-content", contextNode);
                if (scroller)
                    Ext.get(scroller).scrollTo("top", 0);
            }, this);
        this.delayUpdateWidgets.delay(1000);
    },

    updateEntryByIndex: function(treeIndex) {

        if (!this.dtStore || (this.dtStore.proxy.func !== ListService.fetchResults))
            return false;

        var execOptions = this.dtStore.lastOptions.params.serviceMethodParams.filter.execOptions;
        var pageSize = execOptions.maxResultCount;

        execOptions.startingIndex = Math.floor(treeIndex/pageSize) * pageSize;
        this.dtStore.on("load", function() {
            this.adjustSavedGridPage();
            kw.Progress.EndProgress(this);
            this.updateForNextPrevious(treeIndex % pageSize);
        }, this, {single:true});
        kw.Progress.ShowProgress(this);
        this.dtStore.reload();

        return true;
    },

    adjustSavedGridPage: function() {
        var execOptions = this.dtStore.lastOptions.params.serviceMethodParams.filter.execOptions;
        var ctx = new kw.Context(this.context.getUrl());
        ctx.id = this.datatableId;

        Ext.apply(kw.PagingToolbar.savedGridPageNumber, {
            url: ctx.getUrl(),
            objectId: this.datatableId,
            datalistId: this.dtStore.queryId,
            page: execOptions.startingIndex/execOptions.maxResultCount + 1,
            timestamp: new Date()
        });
    },

    onRender: function(ct, pos) {
        this.pageControl = kw.widget.PageControl.getPageControlForWidget(this.parent);
        var pageControl = this.pageControl;
        this.context = pageControl.context;
        if (this.record) {
            this.record.data.i_folder_id =  this.context.getContextProperties().get("i_folder_id");
            this.context.setContextProperties(this.record, {updateRawProperties: true});
        }
        pageControl.registerProvider('kw.component.IRowControl', this);
        kw.widget.datatable.RowControl.superclass.onRender.apply(this,arguments);

        var meta = this.context.getContextProperties();
        var metatype = meta.getMetaType();
        switch(metatype){
            case kw.MetaType.DATATABLE:
                this.datatableId = this.context.id;
                this.subscriptions.push(kw.Events.subscribe(kw.EventNames.SourcePickerLaunch, onSourcePickerLaunch, this));
                break;
            case kw.MetaType.ROW:
                var retCt =0;
                this.datatableId = kw.Util.getFirst_i_folder_id(meta.get("i_folder_id"), retCt);
                this.subscriptions.push(kw.Events.subscribe(kw.EventNames.ItemModified, onItemModified, this));
                this.subscriptions.push(kw.Events.subscribe(kw.EventNames.SourcePickerLaunch, onSourcePickerLaunch, this));
                break;
            case kw.MetaType.SCHEMA:
                var tab = kw.Util.findTabComponentByClass(ct);
                var qs = tab.fullContext.queryString;
                if (!qs || qs.length<1) throw "url missing datatableid querystring";
                this.datatableId = kw.Util.getQueryStringParam("datatableid", qs);

                if (!this.datatableId) throw "url missing datatableid";
                pageControl.context.primaryId=this.datatableId;

                kw.data.DtMetadataCache.updateCache(this.datatableId, {   // cache the schema id
                    schema_id: this.context.id
                });

                // if not locked, get out!
                var lock=meta.get("r_lock_owner");
                if (lock!=kw.getCurrentMemberUserName(this.context.repository)){
                    // we shouldn't be here
                    var ctx = this.context.getContext();
                    ctx.queryString=null;
                    ctx.id=this.datatableId;
                    kw.HashWatcher.adjustLocation(ctx.getUrl());
                    kw.RendEng.throwPageError(kw.Strings.Datatable.schemaNotLockedByYou);
                    return;
                }

                this.subscriptions.push(kw.Events.subscribe(kw.EventNames.CancelEditing, this.onCancelEditing, this));
                break;
            default:
                kw.Util.debugHere("rowcontrol in wrong page type");
                throw new Error("rowcontrol in wrong page type");
        }

        if (!this.datatableId) {
            kw.Util.debugHere("no datatable id");
        }

        pageControl.enableDrafts(false);
		this.subscriptions.push(kw.Events.subscribe(kw.EventNames.XULBindingComplete, onInitialBinding, this));
        pageControl.on("pageeditmode", onEntryEdit, this, {single:true});
        pageControl.on(kw.EventNames.PageModified, onPageModified, this);
        pageControl.on(kw.EventNames.CancelPageEdit, onSchemaEditCancel, this);
        this.tab = kw.RendEng.tabManager.findTabComponentForNode(pageControl.box.el.dom);
        this.tab.on(kw.EventNames.DeferredBinding, onTabBound, this, {single:true});
        this.tab.on("navigate", onNavigateAway, this);
        this.tab.on("mybeforeclose", onTabClose, this);
        kw.RendEng.getTabManager().on("savetabstate", onSaveTabState, this);
        this.repo = this.context.repository;


        kw.RendEng.registerNavHook(this.navHook,  this);
        kw.RendEng.registerLogoutHook(this.logoutHook, this);

        this.state._isNewEntry = ((metatype== kw.MetaType.DATATABLE) && !this.state._isSchemaPage);

        var box = Ext.get(this.pageControl.box.id);
        this.addViewClasses(box);

        pageControl.on(kw.EventNames.EditPage, onEditSchema, this);

        if (this.state._isSchemaPage) { //
            schemaModeInit.call(this);
        }
        else {
            if (this.state._isNewEntry) {
                this.state._recInStore = false;
                inputModeInit.call(this);
                if (kw.Util.getQueryStringParam("mode", this.context.queryString) == "entry"){
                    var myTab = kw.RendEng.tabManager.findTabComponentForNode(pageControl.box.el.dom);
                    myTab.on(kw.EventNames.DeferredBinding, this.editRow, this, {single: true});
                }
            }
            else{
                viewModeInit.call(this);
            }
        }
    },

    onCancelEditing: function(evtName, actionArgs) {
        if ( (this.state._isSchemaPage) && (this.state._mode == kw.widget.datatable.SCHEMA_MODE)){
            var id = actionArgs.context.getContext(actionArgs.metadata).id;
            if (id==this.datatableId)
                actionArgs.handled=true;
                this.pageControl.unlockPage({});
        }
    },

    doNavigation: function(navContext){
        this.onNavigateWithNoNavHook = navContext;
        kw.RendEng.navigate(navContext);
        this.onNavigateWithNoNavHook = null;
    },

    closeTab: function(){
        var tm = kw.RendEng.getTabManager(true);
        if (tm){
            tm.remove(this.tab);
        }
        this.onSaveSuccessClosetab = null;

    },

    saveEntry: function(){
        var actionArgs = new kw.ActionArgs({
                        context: this.context,
                        metadata: {
                            r_object_type: this.getDatatableRowType(),
                            r_object_id: this.context.id,
                            r_parent_id: this.datatableId
                        }
                    });
        this.saveRow(actionArgs);
    },

    navHook: function(navContext, noNavigate) {
        var msgBody, msgTitle, funct;
        if(this.context.space == navContext.space){
            if (this.onNavigateWithNoNavHook)
                return true;

            // Data table has been deleted, just navigate.
            if (this.datatableId == navContext.deletedId)
                return true;

            var meta = this.context.getSpaceProperties();
            var spaceName = Ext.util.Format.htmlEncode(meta.get("object_name"));
            if ((this.state._isSchemaPage) && (this.state._mode == kw.widget.datatable.SCHEMA_MODE)){

                if (this.context.getContextProperties().get('r_lock_owner') === "")
                    return true;

                if (this.datatableId == navContext.id) { // KWC-8368
                    kw.Util.activateTab(this.pageControl.box.el.dom);
                    return false;  
                }

                msgBody = String.format(kw.Strings.Datatable.entryMasterNavigateAway, spaceName);
                msgTitle = kw.Strings.Datatable.entryNavigateAwayTitle;
                funct = function(buttonId) {
                   if (buttonId == "yes") {
                       this.onNavigateWithNoNavHook = navContext;
                        this.saveSchema();
                   }
                   else if(buttonId == "no"){
                       var ctx = Ext.apply({}, this.context);
                        ctx.id = this.datatableId;
                        ctx.queryString = "";
                        kw.Events.publish(kw.EventNames.NavigationAborted, ctx);
                       kw.Util.activateTab(this.pageControl.box.el.dom);
                       return false;
                   }
                   else{
                        if (kw.RendEng.getTabManager(true).getActiveTab().viewManager){
                            var viewButton = this.tab.viewManager.viewSelector.getViewButton(this.context.view);

                            if (viewButton.view !== kw.RendEng.getTabManager(true).getActiveTab().viewManager.activeView){
                                viewButton.context.id = this.datatableId;
                                viewButton.context.queryString=null;
                            }
                        }
                        this.pageControl.postEditCancel(false);
                        this.doNavigation(navContext);
                   }
               };
            }else if (this.state._isNewEntry || (this.state._mode == kw.widget.datatable.INPUT_MODE)){

                if ( (this.context.id == navContext.id) &&
                     (!this.context.queryString && !navContext.queryString)
                   )
                { // KWC-8368
                    kw.Util.activateTab(this.pageControl.box.el.dom);
                    return false;
                }

                if (this.state._isNewEntry){
                    msgBody = String.format(kw.Strings.Datatable.newEntryNavigateAway, spaceName);
                    msgTitle = kw.Strings.Datatable.newEntryNavigateAwayTitle;
                }else{
                    msgBody = String.format(kw.Strings.Datatable.entryNavigateAway, spaceName);
                    msgTitle = kw.Strings.Datatable.entryNavigateAwayTitle;
                }

                funct = function(buttonId) {
                   if (buttonId == "yes") {
                        if (!noNavigate)
                            this.onNavigateWithNoNavHook = navContext;
                        this.saveEntry();
                   }
                   else if(buttonId == "no"){
                        var ctx = Ext.apply({}, this.context);
                        ctx.id = this.datatableId;
                        ctx.queryString = "";
                        kw.Events.publish(kw.EventNames.NavigationAborted, ctx);
                        kw.Util.activateTab(this.pageControl.box.el.dom);
                        return false;
                   }
                   else{
                       if (!this.state._isNewEntry){
                            if (!noNavigate)
                                this.onNavigateWithNoNavHook = navContext;
                            var actionArgs = new kw.ActionArgs({
                                context: this.context,
                                metadata: {
                                    r_object_type: this.getDatatableRowType(),
                                    r_object_id: this.context.id,
                                    r_parent_id: this.datatableId
                                }
                            });
                            this.cancelEditEntry(actionArgs);
                            if (noNavigate)
                                this.fireEvent("navhookbeforeschemaedit");
                       }else{
                            if (kw.RendEng.getTabManager(true).getActiveTab().viewManager){
                                var viewButton = this.tab.viewManager.viewSelector.getViewButton(this.context.view);

                                if (viewButton.view !== kw.RendEng.getTabManager(true).getActiveTab().viewManager.activeView){
                                    viewButton.context.id = this.datatableId;
                                    viewButton.context.queryString=null;
                                }
                            }
                            if (noNavigate){
                                this.onNavigateWithNoNavHook = true;
                                this.fireEvent("navhookbeforeschemaedit");
                            }
                            else
                                this.doNavigation(navContext);                           
                        }
                   }
               };
            }else{
                return true;
            }
            kw.ScriptLoader.require("js/kw/Dialog/YesNoCancelDialog.js");
            kw.ActionManager.showDialog(kw.Dialog.YesNoCancelDialog,{},
                    {msgBody: msgBody,
                    msgTitle: msgTitle,
                    icon: kw.ScriptLoader.getImagePath() + "emc-ext/window/icon-warning_32.png",
                    dialog: "ThreeButtonDialog",
                    handler: {scope: this, fn: funct}
                    });

            return false;
        }
        return true;
    },

    logoutHook: function() {

        if (this.onLogoutWithNoLogoutHook)
            return true;

        var msgBody, msgTitle, funct;

        var meta = this.context.getSpaceProperties();
        var spaceName = Ext.util.Format.htmlEncode(meta.get("object_name"));
        this.onLogoutWithNoLogoutHook = null;
        if ((this.state._isSchemaPage) && (this.state._mode == kw.widget.datatable.SCHEMA_MODE)){

            msgBody = String.format(kw.Strings.Datatable.entryMasterNavigateAwayBySignout, spaceName);
            msgTitle = kw.Strings.Datatable.entryNavigateAwayTitle;
            funct = function(buttonId) {
                
               if (buttonId == "yes") {
                    this.onLogoutWithNoLogoutHook = this.context;
                    this.saveSchema();                     
               }
               else if(buttonId == "no"){
                    return false;
               }
               else{
                    var curContext = this.context;
                    function afterCancel(cancel){
                        if (cancel){
                            kw.Auth.logout(curContext);
                        }
                    }
                    this.onLogoutWithNoLogoutHook = true;
                    this.pageControl.postEditCancel(false,afterCancel);
               }
           };
        }else if (this.state._isNewEntry || (this.state._mode == kw.widget.datatable.INPUT_MODE)){

            if (this.state._isNewEntry){
                msgBody = String.format(kw.Strings.Datatable.newEntryNavigateAwayBySignout, spaceName);
                msgTitle = kw.Strings.Datatable.newEntryNavigateAwayTitle;
            }else{
                msgBody = String.format(kw.Strings.Datatable.entryNavigateAwayBySignout, spaceName);
                msgTitle = kw.Strings.Datatable.entryNavigateAwayTitle;
            }

            funct = function(buttonId) {
               if (buttonId == "yes") {
                    this.onLogoutWithNoLogoutHook = this.context;
                    this.saveEntry();                    
               }
               else if(buttonId == "no"){
                    return false;
               }
               else{
                   if (!this.state._isNewEntry){
                       var actionArgs = new kw.ActionArgs({
                            context: this.context,
                            metadata: {
                                r_object_type: this.getDatatableRowType(),
                                r_object_id: this.context.id,
                                r_parent_id: this.datatableId
                            }
                        });
                        this.onLogoutWithNoLogoutHook = this.context;
                        this.cancelEditEntry(actionArgs);
                   }else{
                        this.context.queryString=null;
                        this.onLogoutWithNoLogoutHook = true;
                        kw.Auth.logout(this.context);
                   }
               }
           };
        }else{
            return true;
        }

        kw.ScriptLoader.require("js/kw/Dialog/YesNoCancelDialog.js");
        kw.ActionManager.showDialog(kw.Dialog.YesNoCancelDialog,{},
                {msgBody: msgBody,
                msgTitle: msgTitle,
                icon: kw.ScriptLoader.getImagePath() + "emc-ext/window/icon-warning_32.png",
                dialog: "ThreeButtonDialog",
                handler: {scope: this, fn: funct}
                });

        return false;
    },

    onParentDestroy: function() {
        kw.RendEng.unregisterNavHook(this.navHook,  this);
        kw.RendEng.unregisterLogoutHook(this.logoutHook,  this);
        this.pageControl.un("beforexulgeneration", this.form.onBeforeXulGeneration, this.form);

        if (this.dtStore) {
            var s = this.dtStore;
            if (this.tab.fullContext.navData)
                delete this.tab.fullContext.navData.store;
            s.fireEvent("beforedestroy");
            s.destroy();
        }
        
        this.destroy();
    },

    addField: function(f) {
        this.form.add(f);
        if (this.record && this.record.data) {
            f.setValue(this.record.data[f.dataIndex]);
        }
        f.on("configupdate", onFieldUpdate, this);
    },

    removeField: function(f) {
        this.form.remove(f);
    },

    getFieldTitle: function(dataIndex) {
        var f = this.form.findField(dataIndex);
        if (f && f.initialConfig)
            return f.initialConfig.title;

        return "";
    },

    getEntryNameField: function() {//only works on schema page
        return this.form.getTitleField();
    },
    addViewClasses : function(box) {
        //Add specific classes to view mode box since view mode looks different than edit mode
        box.removeClass('kw-page-edit-mode');
        box.removeClass('kw-dt-edit-mode');
        box.addClass('kw-page-view-mode');
        box.addClass('kw-dt-view-mode');
    },
    removeViewClasses : function(box) {
        box.removeClass('kw-page-view-mode');
        box.removeClass('kw-dt-view-mode');
        box.addClass('kw-page-edit-mode');
        box.addClass('kw-dt-edit-mode');
    },
    setMode: function(mode, bTransferValue) {
        var box = Ext.get(this.pageControl.box.id);

        if (mode == kw.widget.datatable.INPUT_MODE || mode == kw.widget.datatable.SCHEMA_MODE){
            this.tab.cssManager.loadCSS("js/kw/css/kw-page-edit-mode.css");
            this.removeViewClasses(box);
            this.fireEvent(kw.EventNames.EditPage);
        }
        else{
            this.tab.cssManager.unloadCSS("js/kw/css/kw-page-edit-mode.css");
            this.addViewClasses(box);
            this.fireEvent(kw.EventNames.ViewPage);
        }
        this.state._mode = mode;
        this.form.setMode(mode, bTransferValue);
    },

    getFieldsFromLayout: function() {

        var fieldComps = this.pageControl.box.findBy(function(compo) {
            if (compo.rendered && compo.el) {
                return compo.el.hasClass("kw-dtfield");
            }
            else if (typeof compo.cls == "string") {
                return compo.cls.indexOf("kw-dtfield") != -1;
            }
            else
                return compo.initialConfig.cls && (compo.initialConfig.cls.indexOf("kw-dtfield") != -1);
        }, this);


        var fields = [];
        for (var i=0; i < fieldComps.length; ++i) {
            var f = fieldComps[i];
            if (f && f.ownerCt) {
                var ctnr = f.ownerCt.ownerCt;
                if (ctnr && ctnr.bindings) {
                    var binding = ctnr.bindings[0];
                    fields.push({
                        widgetId: f.id,
                        rcmpId: binding.getComponentId(),
                        fieldId: f.dataIndex,
                        title: (f.ownerCt.title ? Ext.util.Format.htmlDecode(f.ownerCt.title.trim()) : false) || f.title
                    });
                }
            }
        }
        return fields;
    },

    onSaveRecord: function()
    {
/*
        function onCheckinComplete(opStatusSet)
        {
            kw.Progress.EndProgress(this);

            if (kw.Service.Util.getOpStatusSetSummary(opStatusSet) !== true)
            {
                delete this.saveRowReturnFn;
                handleRowUpdateError.call(this, opStatusSet);
                return;
            }

            this.onSuccessUnlock();

            var curName = this.form.findField(this.getTitleColumn()).getValue();
            var evtactionArgs = new kw.ActionArgs(
            {
                context: this.context,
                metadata:
                {
                    r_object_id: this.context.id,
                    object_name: curName
                }
            });

            kw.Events.publish(kw.EventNames.ItemModified, evtactionArgs);
            this.form.updateRecord(this.record);
            this.fireEvent("rowmodified");
        }
*/
        function onCancelCheckoutComplete()
        {
            kw.Progress.EndProgress(this);

            this.onSuccessUnlock();

            var evtactionArgs = new kw.ActionArgs(
            {
                context: this.context,
                metadata:
                {
                    r_object_id: this.context.id,
                    object_name: this.curObjName
                }
            });

            kw.Events.publish(kw.EventNames.ItemModified, evtactionArgs);
            this.form.updateRecord(this.record);
            var titleColumn = this.getTitleColumn();
            var titleColVal = this.record.get(titleColumn);
            this.record.set("object_name", titleColVal);
            this.fireEvent("rowmodified");
            this.fireEvent("navhookbeforeschemaedit");
        }

        function onUpdateRowComplete(opStatusSet)
        {
            if (kw.Service.Util.getOpStatusSetSummary(opStatusSet) !== true)
            {
                kw.Progress.EndProgress(this);
                delete this.saveRowReturnFn;
                handleRowUpdateError.call(this, opStatusSet);
                return;
            }

            var objIdentity = new ObjectIdentity().init(this.context.repository, this.context.id);
            var idset = { identities: [objIdentity] };
            ContentService.cancelCheckout(idset, kw.getCallbackClosure(this, onCancelCheckoutComplete));
        }

        if (!this.record)
        {
            this.unlockRow({context: this.context}, null);
            return; // nothing to save
        }

        kw.Progress.ShowProgress(this);

        this.curObjName = this.form.findField(this.getTitleColumn()).getValue();
        if (this.curObjName.bodyAsString) {   // richtext object
            this.curObjName = Ext.util.Format.stripTags(this.curObjName.bodyAsString);
            this.curObjName = Ext.util.Format.htmlDecode(this.curObjName.replace(/&nbsp;/g, ' ')).trim();
        }

        var propPackage = getPropertyPackageFromFormData.call(this);
        propPackage.properties._kw_row_lock_time = Ext.util.Format.date(this.lockDate, "Y-m-d\\TH:i:sO");
        processRichTextImages(propPackage.properties);

        //  RGT:  Ultimately, the two chained calls to updateProperties and cancelCheckout should be replaced by just one:
        //  ContentService.checkin.  However, DFS VersionControlService.checkin does not currently handle rich text
        //  properties correctly, and we cannot batch them because we do not want to call cancelCheckout if updateProperties
        //  failed (e.g. there were validation errors).

        ContentService.updateProperties(propPackage, kw.getCallbackClosure(this, onUpdateRowComplete));
/*
        var repositoryName = this.context.repository;
        var dataPackage = new DataPackage().init(repositoryName);
        var dataObject = new DataObject();
        dataObject.identity = new ObjectIdentity().init(repositoryName, this.context.id);
        dataObject.properties = propPackage.properties;
        dataObject.type = this.getDatatableRowType();
        dataPackage.add(dataObject);
        var checkinOptions = new CheckinOptions().init();
        ContentService.checkin(dataPackage, [checkinOptions], kw.getCallbackClosure(this, onCheckinComplete))
*/
    },

    editRow: function() {
        var lockProps = getLockDate.call(this);
        this.lockDate = lockProps.lockDate;
        this.setMode(kw.widget.datatable.INPUT_MODE,  true);

        function beginEdit() {
            var pta = this.pageControl.findPageTitleArea();
            if (pta && pta.rendered) {
                this.fireEvent(kw.EventNames.UpdateDtEntryToolbar, kw.widget.datatable.INPUT_MODE);
            }
            else if (pta) {
                pta.on("afterrender", function() {
                    this.fireEvent(kw.EventNames.UpdateDtEntryToolbar, kw.widget.datatable.INPUT_MODE);
                }, this, {single: true});
            }
            pta.updateActions();
        }

        if (this.form.items && this.form.items.item && this.form.items.items.length &&
            this.form.items.items[0].input &&
                    (this.form.items.items[0].input.xtype == "kwdttextfield" ||
                     this.form.items.items[0].input.xtype == "textfield"    ||
                     this.form.items.items[0].input.ctCls == "kw-dt-date-field-editor"
                     )
                )
        {
            this.form.items.items[0].input.focus(false, true);
        }

        // KWC-18659 At start of edit, compare the current i_vstamp value to the value in the record.
        // If there was an intervening save of the row on another session, the i_vstamp just fetched
        // will be greater than expected. If this happens, we have to refresh the row data.
        if (this.record && this.record.get && (this.record.get("i_vstamp") != (lockProps.vstamp-1))) {
            refreshRowData.call(this, beginEdit, this);
        }
        else {
            beginEdit.call(this);
        }
    },

    getPageTitleArea: function() {
        return this.pageControl.findPageTitleArea();
    },

    getTitleColumn: function() {
        if (this.titleColumn)
            return this.titleColumn;

        var props = getCurrentSchemaProps.call(this);
        this.titleColumn = props.properties.title_column;

        return this.titleColumn;
    },

    getObjLocation: function() {
        var objLoc = new ObjectLocation();
        objLoc.objectIdentity = new ObjectIdentity();
        Ext.apply(objLoc.objectIdentity, {
            repositoryName: this.repo,
            valueType: "OBJECT_ID",
            value: this.datatableId
        });
        return objLoc;
    },

    createRow: function(repo, datatableId) {
        if (repo)
            this.repo = repo;
        if (datatableId)
            this.datatableId = datatableId;

        kw.Progress.ShowProgress(this);
        ContentService.preCreate(
                this.getObjLocation(),
                this.getDatatableRowType(),
                {callback: onPreCreateRowComplete.createDelegate(this)}
           );
    },

    saveRow: function(actionArgs, fnComplete) {
        var pta = this.getPageTitleArea();
        if (!this.form.isValid()) {
            if (pta){
                this.onNavigateWithNoNavHook = null;
                this.onLogoutWithNoLogoutHook = null;
                var ctx = Ext.apply({}, this.context);
                ctx.id = this.datatableId;
                ctx.queryString = "";
                kw.Events.publish(kw.EventNames.NavigationAborted, ctx);
                pta.showErrorBox(true);
                pta.updateActions();
            }
            return;
        }
        else if (pta) {
            pta.showErrorBox(false);
        }

        this.saveRowReturnFn = fnComplete;
        var metaType = actionArgs.context.getContextProperties().getMetaType();
        if (metaType == kw.MetaType.ROW)
            this.onSaveRecord();
        else
            this.createRow();
    },

    cancelEditEntry: function(actionArgs) {
        var pta = this.getPageTitleArea();
        pta.showErrorBox(false);
        kw.Progress.ShowProgress(this);

        function cancelComplete() {
            unlockAndRestore.call(this);
            pta.updateActions();
        }

        var cb = {callback: cancelComplete.createDelegate(this)};
        // we don't expect non-coordinators to always succeed in unlocking a row,
        // because it may be locked by other; so just eat the exception.
        if (!kw.Util.isCoordinator(this.context)) {
            cb.errorHandler = cb.callback;
        }
        this.unlockRow(actionArgs, cb);
        this.form.onCancelEdit();
    },

    onSuccessUnlock: function() {
        this.setMode(kw.widget.datatable.VIEW_MODE, true);
        this.fireEvent(kw.EventNames.UpdateDtEntryToolbar, kw.widget.datatable.VIEW_MODE);

        if (this.saveRowReturnFn) {
            this.onNavigateWithNoNavHook=true;
            var fn=this.saveRowReturnFn;
            delete this.saveRowReturnFn;
            fn();
        } else{
            if (this.onNavigateWithNoNavHook)
                this.doNavigation(this.onNavigateWithNoNavHook);

            if(this.onSaveSuccessClosetab)
                this.closeTab();

            if(this.onLogoutWithNoLogoutHook)
                kw.Auth.logout(this.onLogoutWithNoLogoutHook);
        }
    },

    unlockRow: function(actionArgs, cb) {
        if (!cb)
            cb = this.onSuccessUnlock;

        this.unlock(actionArgs, cb);
    },

    unlock: function(actionArgs, cb) {
        var objIdentity = new ObjectIdentity();
        objIdentity.value = actionArgs.context.id;
        objIdentity.valueType = "OBJECT_ID";
        objIdentity.repositoryName = actionArgs.context.repository;
        var idset = {identities:[objIdentity]};

        var callback;
        if (typeof cb == "function")
            callback = kw.getCallbackClosure(this, cb);
        else
            callback = cb;
        ContentService.cancelCheckout(idset,callback);
    },

    lock: function(actionArgs, onSuccessLockFunc) {
        var objIdentity = new ObjectIdentity();
        objIdentity.value = actionArgs.context.id;
        objIdentity.valueType = "OBJECT_ID";
        objIdentity.repositoryName = actionArgs.context.repository;
        var idset = {identities:[objIdentity]};

        var callback = kw.getCallbackClosure(this, onSuccessLockFunc);
        ContentService.checkout(idset, null, callback);
    },

    onPostXulError: function(response, ioArgs){
        kw.Progress.EndProgress(this);

        var funct = function(buttonId) {
               if (buttonId == "yes")
                    this.saveSchema({}, true);
               else if(buttonId == "no"){}
               else
                    this.pageControl.postEditCancel(true);
            };

        if (response.status == 403){
            var reissue = function() {kw.RendEng.postXul(ioArgs);};
            kw.Util.handleAuth403(reissue);
            return;
        }
        else if (ioArgs.savingPage) {

            var propertyConfig, properties; 
            var msg = Ext.DomQuery.selectValue("message", response.responseXML);
            kw.Util.debug("RE: post error: " + msg);

            var messageId = Ext.DomQuery.selectValue("messageId", response.responseXML);
            var fCoordinator = this.context.getSpaceProperties().get("_kw_effective_role") == kw.Roles.COORDINATORS;

            if(messageId == "KW_E_DATATABLE_NEWER_VERSION"){

            propertyConfig = {context:this.context, profile:{includeProperties: ["r_modifier"]}};
            properties = new kw.Properties(propertyConfig);
            properties.load(true);

            kw.ScriptLoader.require("js/kw/Dialog/YesNoCancelDialog.js");
            kw.ActionManager.showDialog(kw.Dialog.YesNoCancelDialog,{},
                                    {msgBody: String.format(kw.Strings.Datatable.saveSchemaChangesPrompt, properties.get("r_modifier")),
                                    msgTitle: String.format(kw.Strings.Datatable.SaveChangesTitle, properties.get("r_modifier")),
                                    icon: kw.ScriptLoader.getImagePath() + "emc-ext/window/icon-error_32.png",
                                    dialog: "ThreeButtonDialog",
                                    handler: {scope: this,fn: funct}
                                    }
                    );
            }
            else if(messageId == "KW_DATATABLE_NOT_LOCKED_BY_YOU")
            {
                if (fCoordinator){
                    propertyConfig = {context:this.context, profile:{includeProperties: ["r_lock_owner", "_kw_page_lock"]}};
                    properties = new kw.Properties(propertyConfig);
                    properties.load(true);

                    kw.ScriptLoader.require("js/kw/Dialog/YesNoCancelDialog.js");
                    kw.ActionManager.showDialog(kw.Dialog.YesNoCancelDialog,{},
                                    {msgBody: String.format(kw.Strings.Datatable.overrideSchemaChangesPrompt, properties.get("r_lock_owner")),
                                    msgTitle: String.format(kw.Strings.Datatable.SaveChangesTitle, properties.get("r_lock_owner")),
                                    icon: kw.ScriptLoader.getImagePath() + "emc-ext/window/icon-error_32.png",
                                    dialog: "ThreeButtonDialog",
                                    handler: {scope: this,fn: funct}
                                    }
                    );
                }else{
                    propertyConfig = {context:this.context, profile:{includeProperties: ["r_lock_owner", "_kw_page_lock"]}};
                    properties = new kw.Properties(propertyConfig);
                    properties.load(true);
                    kw.ScriptLoader.require("js/kw/Dialog/YesNoCancelDialog.js");
                    kw.ActionManager.showDialog(kw.Dialog.YesNoCancelDialog,{},
                                    {msgBody: String.format(kw.Strings.Datatable.discardSchemaChangesPrompt, properties.get("r_lock_owner")),
                                    msgTitle: String.format(kw.Strings.Datatable.SaveChangesTitle, properties.get("r_lock_owner")),
                                    icon: kw.ScriptLoader.getImagePath() + "emc-ext/window/icon-error_32.png",
                                    dialog: "TwoButtonDialog",
                                    handler: {scope: this,fn: funct}
                                    }
                    );
                }
            }
            else if (messageId == "KW_E_OBJECT_DOES_NOT_EXIST" ) {
                kw.Events.publish(kw.EventNames.ErrorReport, new kw.Error.Report({message: kw.Strings.Datatable.cantSaveSchemaNoExist}));
            }
            else
            {
                if (!msg)
                    msg = response.status;
                msg = String.format(kw.Strings.Error.postError, msg);
                kw.Events.publish(kw.EventNames.ErrorReport, new kw.Error.Report({message: msg}));
            }
        }
    },

    saveSchema: function(actionArgs, force) {

        var saveSuccess = function(resp, options)
        {
            this.pageControl.onPostXulOk(resp, options);

            kw.data.clearQueryMetadata(this.datatableId);

            if (this.onNavigateWithNoNavHook){
                var viewButton = this.tab.viewManager.viewSelector.getViewButton(this.context.view);

                if (viewButton.view !== kw.RendEng.getTabManager(true).getActiveTab().viewManager.activeView){
                    viewButton.context.id = this.datatableId;
                    viewButton.context.queryString=null;
                }
                this.doNavigation(this.onNavigateWithNoNavHook);
            }
            else if(this.onSaveSuccessClosetab)
                this.closeTab();
            else if (this.onLogoutWithNoLogoutHook)
                  kw.Auth.logout(this.onLogoutWithNoLogoutHook);
            else
                navToSummaryPage.call(this);

        }.createDelegate(this);

        if (this.allowComments)
        {
            var meta = this.context.getContextProperties();
            var oldAllowComments = meta.get('_kw_enable_comments');
            var newAllowComments = this.allowComments.getValue();
            var entryCount = getEntryCount.call(this);
            
            if (entryCount > 0 && oldAllowComments && !newAllowComments)
            {
                kw.MessageBox.show(
                {
                    title: kw.Strings.Action.SaveSchema._confirmDisableCommentsTitle,
                    msg: kw.Strings.Action.SaveSchema._confirmDisableCommentsMsg,
                    cls: 'kw-msg-alert',
                    buttons: Ext.MessageBox.YESNO,
                    icon: Ext.MessageBox.WARNING,
                    scope: this,
                    fn: function(btn)
                    {
                        if (btn == 'yes')
                            this.doSaveSchema({}, saveSuccess);
                    }
               });
               return;
            }
        }

        var schemaArgs = {
            savingPage:true,
            progString: kw.Strings.ProcessingChanges,
            force: force
        };

        this.doSaveSchema(schemaArgs, saveSuccess);
    },

    doSaveSchema: function(postOpts, onSuccess) {
        if (this.getMode() != kw.widget.datatable.SCHEMA_MODE) {
            return;
        }
        var pta = this.getPageTitleArea();

        if (!this.form.isValid()) {
            pta.showErrorBox(true);
            return;
        }else{
            pta.showErrorBox(false);
        }
        
        var properties = {};
        if (!postOpts.force) {
            var modDate = this.context.getContextProperties().get('r_modify_date');
            if (!(/[0-9]{6}/.test(modDate))) { // at least 6 consecutive numbers means date is in numeric form
                modDate = Date.parse(modDate);
            }
            properties.r_modify_date = modDate;
        }
        if (postOpts.force){
            properties = Ext.apply((properties == null) ? {} : properties, {kw_force_save: true});
        }


        var attrs = {
            modified: this.pageControl.isPageModified(),
            mutable: true
        };

        var xulGenCfg = {};

        var propertyMap = [
            {name: "r_modify_date", type: "ns3:DateProperty"},
            {name: "kw_force_save", type: "ns3:BooleanProperty"}
        ];
        this.pageControl.fireEvent("beforexulgeneration", properties, propertyMap);
        var xul = new kw.XulGenerator.Exec(xulGenCfg).savePageContent(this.context, this.pageControl.box, attrs, properties, propertyMap);
        var postArgs = {
            url:        this.context.getUrl(true),
            xmlData:    xul,
            savingPage: true,
            progString: kw.Strings.ProcessingChanges,
            success:    onSuccess,
            failure:    this.onPostXulError.createDelegate(this),
            pageTitleArea: pta
        };

        Ext.apply(postArgs, postOpts);
        kw.RendEng.postXul(postArgs);
    },

    getDatatableRowType: function() {
        var typeName;
        if (typeName=kw.data.DtMetadataCache.getProperty(this.datatableId, "_kw_row_type_name")){
            return typeName;
        }else if(this.datatableId==this.context.id
                && (typeName=this.context.getContextProperties().get("_kw_row_type_name", true))){
            kw.data.DtMetadataCache.updateCache(this.datatableId, {_kw_row_type_name: typeName});
            return typeName;
        }

        var identity = new ObjectIdentity();
        identity.repositoryName = this.repo;
        identity.valueType = "OBJECT_ID";
        identity.value = this.datatableId;

        var profile = {includeProperties: ["_kw_row_type_name"]};
        var options = {propertyProfile: profile};
        var callbacks={
            callback: function(data) {
                typeName = data.properties._kw_row_type_name;
                kw.data.DtMetadataCache.updateCache(identity.value, {_kw_row_type_name: typeName});
            },

            errorHandler: function() {
                alert("Error");
                kw.Progress.EndProgress(progress);
            },

            async: false
        };

        ContentService.getObject(identity, options, callbacks);
        return typeName;
    },

    doLayout: Ext.emtpyFn

});

function onEditSchema() {
    this.setMode(kw.widget.datatable.SCHEMA_MODE, true);
    this.pageControl.box.doLayout();
}

function onInitialBinding(evt, actionArgs) {
    if (!this.bindDone && actionArgs.context && (actionArgs.context.id == this.context.id)) {
        this.bindDone = true;

        if (!this.state._isNewEntry)
            initRecord.call(this);
        else
            this.record = this.form.loadDefaultValues();
    }
}

function onTabBound() {
    if (this.bindDone)
        return;
    
    this.bindDone = true;
    if (!this.state._isNewEntry)
        initRecord.call(this);
    else
        this.record = this.form.loadDefaultValues();
}

function processRichTextImages(properties)
{
    var key = 'src=';
    var klen = key.length;
    var body, contents, fc, i, i0, i1, i2, newbody, page, path, prop;
    var tempFileFolderName = kw.getTempFileFolderName();
    var quote;

    for (var name in properties)
    {
        prop = properties[name];
        if (prop && prop.format == 'richtext')
        {
            i0 = 0;
            page = 0;
            body = prop.bodyAsString;
            newbody = [];
            contents = [];
            //  Update any img tag src attribute whose value is a file-cache
            //  url with "cid:n" where n is an index into a contents array.
            while ((i1 = body.indexOf(key,i0)) != -1)
            {
                i1 += klen+1;
                quote = body.charAt(i1-1);
                i2  = body.indexOf(quote,i1);  // KWC-19221 handle either single or double quote characters
                path = body.substring(i1,i2);
                newbody.push(body.substring(i0,i1));
                if (path.indexOf(tempFileFolderName) == 0)
                {
                    fc = new FileContent().init(path,page);
                    contents.push(fc);
                    path = 'cid:' + page;
                    page += 1;
                }
                newbody.push(path);
                newbody.push('"');
                i0 = i2+1;
            }

            if (page > 0)
            {
                if (i0 < body.length)
                    newbody.push(body.substring(i0));
                prop.bodyAsString = newbody.join('');
                prop.contents = contents;
            }
        }
    }
}

function onNavigateAway(){

    if(this.onLogoutWithNoLogoutHook)
        return true;

    if((this.state._isSchemaPage) && (this.state._mode == kw.widget.datatable.SCHEMA_MODE))
        kw.beforeUnloadMessage  = kw.Strings.Datatable.entryMasterExternalNavigateAway;
    else if(this.state._isNewEntry)
        kw.beforeUnloadMessage  = kw.Strings.Datatable.newEntryExternalNavigateAway;
    else if(this.state._mode == kw.widget.datatable.INPUT_MODE)
        kw.beforeUnloadMessage  = kw.Strings.Datatable.entryExternalNavigateAway;
}

function onTabClose() {

    var msgBody, msgTitle, funct;
    var meta = this.context.getSpaceProperties();
    var spaceName = Ext.util.Format.htmlEncode(meta.get("object_name"));
    if ((this.state._isSchemaPage) && (this.state._mode == kw.widget.datatable.SCHEMA_MODE)){

           msgBody = String.format(kw.Strings.Datatable.entryMasterNavigateAway, spaceName);
           msgTitle = kw.Strings.Datatable.entryNavigateAwayTitle;
           funct = function(buttonId) {
               if (buttonId == "yes") {
                   this.saveSchema();
                   this.onSaveSuccessClosetab = true;
                   return true;
               }
               else if(buttonId == "no"){
                    var ctx = Ext.apply({}, this.context);
                    ctx.id = this.datatableId;
                    ctx.queryString = "";
                    kw.Events.publish(kw.EventNames.NavigationAborted, ctx);
                    return false;
               }
               else{
                    this.pageControl.postEditCancel(false);
                    this.closeTab();
                    return true;
               }
           };
        }else if (this.state._isNewEntry || (this.state._mode == kw.widget.datatable.INPUT_MODE)){

            if (this.state._isNewEntry){
                msgBody = String.format(kw.Strings.Datatable.newEntryNavigateAway, spaceName);
                msgTitle = kw.Strings.Datatable.newEntryNavigateAwayTitle;
            }else{
                msgBody = String.format(kw.Strings.Datatable.entryNavigateAway, spaceName);
                msgTitle = kw.Strings.Datatable.entryNavigateAwayTitle;
            }
            funct = function(buttonId) {
               if (buttonId == "yes") {
                   this.saveEntry();
                   this.onSaveSuccessClosetab = true;
                   return true;
               }
               else if(buttonId == "no"){
                    var ctx = Ext.apply({}, this.context);
                    ctx.id = this.datatableId;
                    ctx.queryString = "";
                    kw.Events.publish(kw.EventNames.NavigationAborted, ctx);
                    return false;
               }
               else{
                   if (!this.state._isNewEntry){
                       this.onSaveSuccessClosetab = true;
                       var actionArgs = new kw.ActionArgs({
                            context: this.context,
                            metadata: {
                                r_object_type: this.getDatatableRowType(),
                                r_object_id: this.context.id,
                                r_parent_id: this.datatableId
                            }
                        });
                        this.cancelEditEntry(actionArgs);
                    }else{
                        this.closeTab();
                    }
                    return true;
               }
           };
        }else{
            return true;
        }

        kw.ScriptLoader.require("js/kw/Dialog/YesNoCancelDialog.js");
        kw.ActionManager.showDialog(kw.Dialog.YesNoCancelDialog,{},
                {msgBody: msgBody,
                msgTitle: msgTitle,
                icon: kw.ScriptLoader.getImagePath() + "emc-ext/window/icon-warning_32.png",
                dialog: "ThreeButtonDialog",
                handler: {scope: this, fn: funct}
                });

        return false;
}

function onSaveTabState(tabState, context){
    if (this.onLogoutWithNoLogoutHook){
        if (this.state._isSchemaPage){
            context.id = this.datatableId;
            context.queryString = null;
            tabState.url = context.getUrl();
        }else if(this.state._isNewEntry){
            context.queryString = null;
            tabState.url = context.getUrl();
        }
    }
}

function viewModeInit() {
}

function inputModeInit() {
    this.setMode(kw.widget.datatable.INPUT_MODE, true);
}

function schemaModeInit() {
        this.pageControl.on("beforexulgeneration", this.form.onBeforeXulGeneration, this.form);
}

function onPreCreateRowComplete(argPropPkg) {
    var dataPackage = new DataPackage();
    var dataObject = new DataObject();

    dataPackage.dataObjects = [dataObject];
    dataPackage.repositoryName = this.repo;
    dataObject.type = this.getDatatableRowType();
    dataObject.identity = new ObjectIdentity();
    dataObject.identity.repositoryName = this.repo;

    var props = dataObject.properties = new PropertySet();
    var propPkg = getPropertyPackageFromFormData.call(this);
    Ext.apply(props, propPkg.properties);
//    var titleField = this.getTitleColumn();
    //TODO props._kw_row_type_vstamp = argPropPkg.properties._kw_row_type_version;

    processRichTextImages(dataPackage.dataObjects[0].properties);

    ContentService.create(dataPackage, this.getObjLocation(), {callback: onCreateRowComplete.createDelegate(this)});
}

function onCreateRowComplete(opStatusSet) {
    kw.Progress.EndProgress(this);
    if (kw.Service.Util.getOpStatusSetSummary(opStatusSet) !== true) {
        delete this.saveRowReturnFn;
        handleRowUpdateError.call(this, opStatusSet);
        return;
    }

    if (opStatusSet.operationStatusSet.length == 0) {
        kw.Util.debugHere("bogus return");
        alert("debug: bogus return from service -- empty opStatus");
        return;
    }

    var actionArgs = new kw.ActionArgs({
        context: this.context,
        metadata: {
            r_object_type: this.getDatatableRowType(),
            r_object_id: opStatusSet.operationStatusSet[0].objectId.value,
            r_parent_id: this.datatableId
        }
    });
    kw.Events.publish(kw.EventNames.ItemCreated, actionArgs);
    this.fireEvent("navhookbeforeschemaedit");
    var ctx=this.context.getContext(actionArgs.metadata);
    ctx.queryString=null;

    if (this.saveRowReturnFn) {
        this.onNavigateWithNoNavHook=true;
        var fn=this.saveRowReturnFn;
        delete this.saveRowReturnFn;
        fn();
    }
    else if (this.onNavigateWithNoNavHook){
        if (kw.RendEng.getTabManager(true).getActiveTab().viewManager){
            var viewButton = this.tab.viewManager.viewSelector.getViewButton(this.context.view);
            if (viewButton.view !== kw.RendEng.getTabManager(true).getActiveTab().viewManager.activeView){
                viewButton.context.id = opStatusSet.operationStatusSet[0].objectId.value;
                viewButton.context.queryString=null;
            }
        }
        this.doNavigation(this.onNavigateWithNoNavHook);
    }
    else if(this.onSaveSuccessClosetab)
        this.closeTab();
    else if(this.onLogoutWithNoLogoutHook)
        kw.Auth.logout(this.onLogoutWithNoLogoutHook);
    else{
        this.onNavigateWithNoNavHook = ctx;
        kw.RendEng.navigate(ctx);
        this.onNavigateWithNoNavHook = null;
    }
}



/* unused?
function getGrid() {
    if (this.grid) {
        return this.grid;
    }

    var g = this.pageControl.getProviders("kw.component.IDataTableGrid");
    if (g.length) {
        this.grid = g[0];
        this.grid.onStoreEvent("load", function() {
            this.grid.selectRow(this.context.id);
        }, this);

        this.context.setDataTableProperties(this.grid.context.getDataTableProperties());
        return this.grid;
    }

    return null;
}*/

function handleRowUpdateError(opStatusSet, excObject) {
    var msgId;
    if (excObject)
        msgId = excObject.messageId;
    else
        msgId = kw.Service.Util.getMessageId(opStatusSet, 0);

    var ctx = Ext.apply({}, this.context);
    ctx.id = this.datatableId;
    ctx.queryString = "";
    kw.Events.publish(kw.EventNames.NavigationAborted, ctx);
    var errmsg, schemaProps, lockedBy, newRowProps;
    switch (msgId) {
        // Happens when required column has been removed from and new required column added to schema
        case "E_VALIDATE_ACTION_FAILED":
        case "DM_VALIDATION_E_ATTR_RULES_NO_VAL":  //  TODO:  is this now masked by E_VALIDATE_ACTION_FAILED?
        // Happens when required column/colum has been removed from schema
        case "DM_API_E_BADATTRNAME": // TODO:  have server return better error message Id here?
        case "DM_DATA_DICT_E_DD_HANDLE_ATTR_NOT_FOUND":
            var lastModifier = "";
            schemaProps = getCurrentSchemaProps.call(this);
            if (schemaProps)
                lastModifier = schemaProps.properties.r_modifier || "";
            errmsg = String.format(kw.Strings.Datatable.schemaChanged, lastModifier);

            kw.MessageBox.show({
                msg:     errmsg,
                buttons: {ok: kw.Strings.btnClose},
                icon:    Ext.MessageBox.ERROR,
                cls:     'kw-msg-alert'
            }, null);

            break;
        //Happens when entry has been deleted while someone is editing it and trying to save
        case "KW_E_OBJECT_DOES_NOT_EXIST":
            kw.Events.publish(kw.EventNames.ErrorReport, new kw.Error.Report({message: kw.Strings.Datatable.cantSaveEntryNoExist}));
            break;
        case "KW_E_DATATABLE_E_LOCKED":
        case "DMC_DATATABLE_E_LOCKED":
            lockedBy = "";
            schemaProps = getCurrentSchemaProps.call(this);
            if (schemaProps)
                lockedBy = schemaProps.properties.r_lock_owner || "";
            errmsg = String.format(kw.Strings.Datatable.schemaLocked, lockedBy);

            kw.MessageBox.show({
                msg:     errmsg,
                buttons: {ok: kw.Strings.btnClose},
                icon:    Ext.MessageBox.ERROR,
                cls:     'kw-msg-alert'
            }, null);

            break;

        case "KW_E_UPDATE_FAIL_OBJECT_CHECKED_OUT":
        case "KW_E_ROW_LOCKED_BY_ANOTHER":
            newRowProps = refreshRowProps.call(this);
            if (kw.Util.isCoordinator(this.context)) {
                allowOverwrite.call(this, newRowProps, newRowProps.properties.r_lock_owner, kw.Strings.Datatable.entryLockedByOtherCoord);
            }
            else {
                lockedBy = "";
                if (newRowProps)
                    lockedBy = newRowProps.properties.r_lock_owner || "";
                errmsg = String.format(kw.Strings.Datatable.entryLockedByOther, lockedBy);
                kw.MessageBox.show({
                    msg:     errmsg,
                    buttons: {ok: kw.Strings.btnClose},
                    icon:    Ext.MessageBox.ERROR,
                    cls:     'kw-msg-alert'
                }, null);
            }
            break;

       case "KW_E_MORE_RECENT_ROW_EXIST":
            newRowProps = refreshRowProps.call(this);
            allowOverwrite.call(this, newRowProps, newRowProps.properties.r_modifier, kw.Strings.Datatable.entrySavedByOther);
            break;

        default:
            if (opStatusSet)
                kw.ActionLib.handleStatusReturn(opStatusSet);
            else {
                var report = new kw.Error.Report({message:excObj.message, url:window.location.href});
                kw.Events.publish(kw.EventNames.ErrorReport, report);
            }
    }
}

function getCurrentSchemaProps() {
    var csp;
    var schemaId = this.context.getContextProperties().get('schema_id');
    if (!schemaId) {
        schemaId = kw.data.DtMetadataCache.getProperty(this.datatableId, "schema_id");
    }
    if (!schemaId) {
        // if user navs directly to entry without visiting summary page, the schema
        // id has to be fetched
        schemaId = fetchSchemaId.call(this);
        kw.data.DtMetadataCache.updateCache(this.datatableId, {schema_id: schemaId});
    };

    var ident = new ObjectIdentity();
    ident.repositoryName = this.repo;
    if (schemaId) {
        ident.valueType = "OBJECT_ID";
        ident.value = schemaId;
    }

    var opts = {propertyProfile: {includeProperties: ["r_modify_date", "r_modifier", "r_lock_owner", "title_column"]}, async: false};

    function _ok(propPkg) {
        csp = propPkg;
    }
    var cb = kw.getCallbackClosure(this, _ok);
    cb.async = false;

    ContentService.getObject(ident, opts, cb);
    return csp;
}

function fetchSchemaId() {
    var ident = new ObjectIdentity();
    ident.repositoryName = this.repo;
    ident.valueType = "OBJECT_ID";
    ident.value = this.datatableId;

    var opts = {propertyProfile: {includeProperties: ["schema_id"]}, async: false};
    var props;
    function _ok(propPkg) {
        props = propPkg;
    }
    var cb = kw.getCallbackClosure(this, _ok);
    cb.async = false;

    ContentService.getObject(ident, opts, cb);
    return props.properties.schema_id.id;
}

function refreshRowProps() {
    var rowProps;

    var ident = this.context.getObjectIdentity();
    var opts = {propertyProfile: {includeProperties: ["r_modify_date", "r_modifier", "r_lock_owner", "_kw_space_urlname"]}, async: false};

    function _ok(propPkg) {
        rowProps = propPkg;
    }
    var cb = kw.getCallbackClosure(this, _ok);
    cb.async = false;

    ContentService.getObject(ident, opts, cb);
    this.updatedProps = rowProps;
    return rowProps;
}

function unlockAndRestore() {
    kw.Progress.EndProgress(this);
    this.onSuccessUnlock();
    if (!this.isDestroyed && this.record)   // KWC-17930
        this.form.loadRecord(this.record);
}

function onEntryLoad(store, results, params){
    this.record = store.getAt(0);
    this.state._recInStore = true;
    this.form.loadRecord(this.record);
}

function refreshRowData(completion, scope) {
    var query = {
        datalistId: "datatable_entry_query",
        repositories: [this.context.repository],
        context: kw.Util.getListQueryContainerContext(this.context.id),
        cacheable: false
    };

    var filter = new FilterInfo();
    filter.parameters = [
        {name: "entry_id", value: this.context.id},
        {name: "space_id", value: this.context.getSpaceId()}
    ];
    filter.cacheBuster = new Date();

    var cb = kw.getCallbackClosure(this, function(data){
        var rec = this.record;
        var colDefs = data.metaData.columnDefinition;
        var cells = data.rows[0].cells;
        for (var i=0; i < colDefs.length; ++i) {
            this.record.set(colDefs[i].columnName, cells[i].value);
        }

        this.form.loadRecord(this.record);
        
        completion.call(scope);
    } );

    ListService.fetchResults(query, filter, null, cb);
}


function initRecord() {
    if (this.state._isSchemaPage) {
        return;
    }

    // TODO: need to pass the store object through row context.
    if( !this.dtStore ) { // if no store in cache
        var store = new kw.data.Store({
                    proxy: new  kw.data.DWRProxy(ListService.fetchResults),
                    reader:  new kw.data.ServiceResultsReader(),
                    queryId: "datatable_entry_query",
                    remoteSort: true
        });
        var filter = new FilterInfo();
        filter.parameters = [{name: "entry_id", value: this.context.id},
            {name:"space_id", value: this.context.getSpaceId()}];

        var storeLoadParams = { serviceMethodParams : new Object({
                                     listQuery: {datalistId: "datatable_entry_query",
                                     repositories: [this.context.repository],
                                     context: kw.Util.getListQueryContainerContext(this.context.id)
                               },
                               filter: filter, sorting: null})};

        store.on('load', onEntryLoad, this);
        store.load({params: storeLoadParams});
    }
    else{
        this.form.loadRecord(this.record);
    }
}

function onFieldUpdate(field) {
    field.setMode(this.state._mode);
}

function onEntryEdit(){
    if (!this.state._isSchemaPage)
        return false;
    else
        return true;
}

function onPageModified(evtArgs) {
    if (evtArgs.reason == "delete" && this.form) {
        this.form.removeDestroyedItems();
    }
}

function onSchemaEditCancel(evtArgs) {
    this.onNavigateWithNoNavHook = evtArgs.navContext;
    evtArgs.navContext = Ext.apply({}, this.context);
    evtArgs.navContext.queryString = "";
    evtArgs.navContext.id = this.datatableId;
    checkForMoveToNewSpace.call(this, evtArgs.navContext);
}

function checkForMoveToNewSpace(ctx) {
    // The only purpose for this method is to guard against a
    // highly unlikely scenario in which the data table is
    // unlocked and moved to a different space while another
    // user is editing the schema (KWC-8304). So...what we have
    // to do is call getObject to make sure we have the actual
    // current space of the DT, and if it has changed we modify
    // the nav context so that the summary page will open in the
    // correct space, AND we have to nav the old space back to the
    // content top.
    var identity = new ObjectIdentity();
    identity.repositoryName = ctx.repository;
    identity.valueType = "OBJECT_ID";
    identity.value = ctx.id;
    var profile = {includeProperties: ["_kw_space_urlname"]};
    var options = {propertyProfile: profile};
    var callbacks={
        callback: function(data) {
            var targetSpace = data.properties._kw_space_urlname;
            if (targetSpace != ctx.space) {
                var curTabNavCtx = Ext.apply({}, ctx);
                ctx.space = targetSpace;
                curTabNavCtx.id = ""; // top of content view
                delete curTabNavCtx.queryString;
                kw.RendEng.navigate(curTabNavCtx);
            }
        },
        errorHandler: function() {
        },
        async: false
    };
    ContentService.getObject(identity, options, callbacks);
}

function getPropertyPackageFromFormData() {
    var propPackage = new PropertyPackage();
    propPackage.identities=[this.context.getObjectIdentity()];
    propPackage.properties = {};
    this.form.items.each( function(f) {
        if (f.submitValue != false) {
            var value = (f.getSubmitValue) ?  f.getSubmitValue() : f.getValue();
            propPackage.properties[f.dataIndex] = value; // TODO: only if dirty?
        }
    });
    return propPackage;
}

function allowOverwrite(rowProps, memberName, text) {
    var responseHandler = function(buttonId){
        if (buttonId == "yes")
            saveChanges.call(this, rowProps);
    };

    Ext.MessageBox.buttonText.yes = kw.Strings.Datatable.saveChanges;
    Ext.MessageBox.buttonText.no = kw.Strings.Datatable.returnToEditing;
    kw.MessageBox.show({
            msg:     String.format(text, memberName, memberName),
            buttons: Ext.MessageBox.YESNO,
            icon:    Ext.MessageBox.ERROR,
            cls:     'kw-msg-alert',
            fn:      responseHandler.createDelegate(this)
        }, null);
    Ext.MessageBox.buttonText.yes = kw.Strings.btnYes;
    Ext.MessageBox.buttonText.no = kw.Strings.btnNo;
}

function saveChanges(rowProps){
    var curMember = kw.getCurrentMemberInfo(this.context.repository);
    var lockedBy = rowProps.properties.r_lock_owner;

    if (lockedBy && (lockedBy != curMember.properties.user_name)) {
        this.unlock({context: this.context}, lockAndSave);
    }
    else if (!lockedBy) {
        lockAndSave.call(this);
    }
    else if (rowProps.properties._kw_space_urlname != this.context.space) { //  DT is moved
            this.lockDate = null;//force save.
            this.onSaveRecord();
    }
    else {
            this.onSaveRecord();
    }
}

function lockAndSave() {
    function lockAndSaveCallback () {
        this.lockDate = getLockDate.call(this).lockDate;
        this.onSaveRecord();
    }
    this.lock({context: this.context}, lockAndSaveCallback);
}

function navToSummaryPage() {
    var ctx = Ext.apply({}, this.context);
    ctx.id = this.datatableId;
    ctx.queryString = "";
    this.onNavigateWithNoNavHook = ctx;
    checkForMoveToNewSpace.call(this, ctx);
    kw.RendEng.navigate(ctx);
    this.onNavigateWithNoNavHook = null;
}

function getEntryCount() {
    var ident = new ObjectIdentity();
    ident.repositoryName = this.repo;
    ident.valueType = "OBJECT_ID";
    ident.value = this.datatableId;
    
    var opts = {propertyProfile: {includeProperties: ["r_link_cnt"]}, async: false};
    var props;
    function _ok(propPkg) {
        props = propPkg;
    }
    var cb = kw.getCallbackClosure(this, _ok);
    cb.async = false;

    ContentService.getObject(ident, opts, cb);
    return props.properties.r_link_cnt;
}

function getLockDate() {
    var ident = new ObjectIdentity();
    ident.repositoryName = this.repo;
    ident.valueType = "OBJECT_ID";
    ident.value = this.context.id;

    var opts = {propertyProfile: {includeProperties: ["r_lock_date", "i_vstamp"]}, async: false};
    var props;
    function _ok(propPkg) {
        props = propPkg;
    }
    var cb = kw.getCallbackClosure(this, _ok);
    cb.async = false;

    ContentService.getObject(ident, opts, cb);
    return {
        lockDate:     props.properties.r_lock_date,
        vstamp:       props.properties.i_vstamp
    };

}

function onItemModified(evt, evtactionArgs) {
    var modId = evtactionArgs.metadata.get("r_object_id");
    if ((modId == this.context.id) && (evtactionArgs.notification == kw.Strings.Notification.Cancel)) {
        this.getPageTitleArea().showErrorBox(false);
        this.form.onCancelEdit();
        unlockAndRestore.call(this);
    }
}

function onSourcePickerLaunch(evt, dlgConfig) {
    var myTab = kw.RendEng.tabManager.findTabComponentForNode(this.pageControl.box.el.dom);
    if (myTab === kw.RendEng.getTabManager().getActiveTab())
        dlgConfig.allowImport = this.schemaHasAttachmentField && !this.state._isNewEntry;
}
})();
///////////////////////////////////////////////////////////////////////////////

rcmp.intf.defineInterface("kw.component.IRowControl", [
        "renderPanel",
        "addField",
        "getFieldTitle"
]);

rcmp.intf.implementInterface(kw.widget.datatable.RowControl, "kw.component.IRowControl");

// Static methods

// This method walks UP the component tree to find a row control. To walk DOWN from a known node,
// use getRowControl.
kw.widget.datatable.getRowControlForWidget = function(f) {
    var pc = kw.widget.PageControl.getPageControlForWidget(f);
    if (!pc) {
        if (!f.rendered)
            f = f.ownerCt;
        pc = kw.widget.PageControl.getPageControl(f.el.dom);
    }
    if (pc) {
        var rcs = pc.getProviders("kw.component.IRowControl");
        if (rcs.length)
            return rcs[0];
    }
    return null;
};

// Finds a row control in the DOM tree BELOW the specified node
kw.widget.datatable.getRowControl = function(domNode) {
    var cnode = kw.RendEng.findContextNode("page", domNode);
    if (cnode) {
        var compo = Ext.getCmp(cnode.id);
        cnode = null;
        if (compo) {
            var pc = compo.pageControl;
            if (pc) {
                var rcs = pc.getProviders("kw.component.IRowControl");
                if (rcs.length)
                    return rcs[0];
            }
        }
    }
    return null;
};

Ext.namespace("kw.debug");
kw.debug.RowControl = function() {eval("debugger");};

// TextSearchField.js

var pkg = rcmp.packageFromPath("cma.kw.form", true);

pkg.TextSearchField = function(config) {
    pkg.TextSearchField.superclass.constructor.call(this, config);
    rcmp.intf.attachInterfaces(this, pkg.TextSearchField);    
    var iDtSearchField = rcmp.intf.getInterface(this, "kw.component.IDtSearchField");
    iDtSearchField.setSearchFilter(config.searchExpression);
}

Ext.extend(pkg.TextSearchField, Ext.form.TextField,{
    getSearchExpressions: function() {
        var value = pkg.TextSearchField.superclass.getValue.call(this);
        if (!Ext.isEmpty(value)) {
            var propExp = new PropertyExpression();
            propExp.property = this.dtFieldInfo.columnName;
            propExp.condition = "CONTAINS";
            propExp.value = new SimpleValue();
            propExp.value.value = value;
            return propExp;
        }

        return null;
    },

    setSearchFilter:function(searchExpression) {
        if (!searchExpression) return;
        this.value = searchExpression.value.value;
    },

    resetSearchFilter: function() {
        this.setValue("");
    }
});

rcmp.intf.implementInterface(pkg.TextSearchField, "kw.component.IDtSearchField");

Ext.reg("textsearchfield", pkg.TextSearchField);
/* TitleInput.js */

(function() {

    Ext.namespace("kw.widget.datatable");

    kw.widget.datatable.TitleInput = Ext.extend(Ext.form.TextField, {
        constructor: function(cfg) {
            cfg = Ext.apply(cfg || {}, {
                validator: validateUniqueTitle.createDelegate(this),
                validateOnBlur: true
            });
            kw.widget.datatable.TitleInput.superclass.constructor.call(this, cfg);
        }
    });

    function validateUniqueTitle(newTitle) {
        return "Field title is already in use";
    }

    Ext.reg("titleinput", kw.widget.datatable.TitleInput);

})();

/* CheckTextCombo.js */

Ext.namespace("kw.widget.datatable.config");

// This control combines a checkbox with a text input. The assumption is that the text input is used to input
// a positive integer.
//
//  Control values
//     A negative value means unchecked.
//     A positive value means checked.
//     Zero means unchecked and blank.
//     A non-zero value is always rendered as a positive integer (with or without check mark)

(function() {
    
kw.widget.datatable.config.CheckTextCombo = function(config) {

    kw.widget.datatable.config.CheckTextCombo.superclass.constructor.call(this, config);
    this.reset();
    if (config.value) {
        this.value = config.value;
    }

    var _cb=null, _ti=null;
    this.getCheckbox = function() {
        if (!_cb) {
            _cb = Ext.DomQuery.selectNode(".kw-chktxtcombo-chk", this.el.dom);
        }
        return _cb;
    };

    this.getTextInput = function() {
        if (!_ti) {
            _ti = Ext.DomQuery.selectNode(".kw-chktxtcombo-txt", this.el.dom);
        }
        return _ti;
    }
};

function onClickCheckbox() {
    var cb = this.getCheckbox();
    if (cb.checked) {
        enableTextInput.call(this);
    } else{
        disableTextInput.call(this);
    }
}

function enableTextInput() {
    this.getTextInput().disabled = false;
    this.el.removeClass("kw-disabled");
}

function disableTextInput() {
    this.getTextInput().disabled = true;
    this.el.addClass("kw-disabled");
}

Ext.extend(kw.widget.datatable.config.CheckTextCombo, Ext.form.Field,{
    onRender: function(ct, pos) {
        if (this.el) {
            return;
        }
        this.el = Ext.get(document.createElement('div'));
        this.el.id = this.id;
        this.el.dom.id = this.id;
        this.el.addClass("kw-chktxtcombo");
        var trail = this.initialConfig.trailing;
        if (!trail) {
            trail = "";
        }
        var markup = [
                "<div class=\"kw-chktxtcombo\">",
                    "<input class=\"kw-chktxtcombo-chk\" type=\"checkbox\"/>",
                    "<input class=\"kw-chktxtcombo-txt\" type=\"text\"/>",
                    "<span>" + trail + "</span>",
                "</div>"
                ].join("");

        this.el.update(markup);
        kw.widget.datatable.config.CheckTextCombo.superclass.onRender.apply(this, arguments);

        this.getCheckbox().onclick = onClickCheckbox.createDelegate(this);
        this.setRawValue(this.value);
        if (!this.isChecked()) {
            disableTextInput.call(this);
        }
    },

    isChecked: function() {
        return this.getCheckbox().checked;
    },

    getValue: function() {
        return this.getRawValue();
    },
    getRawValue: function() {
        var checked = this.isChecked();
        var text = this.getTextInput().value;
        var n = parseInt(text, 10);        
        return checked ? n : '';
    },
    
    isValid: function() {
        return true;
    },
    isDirty: function() {
        return true;
    },
    reset: function() {
        this.setValue(0);
    },
    setValue: function(a) {
        this.setRawValue(a);
    },
    setRawValue: function(a) {
        this.value = a;
        var checked;
        var text;
        if (a === 0) {
            checked = false;
            text = "";
        }
        else {
            checked = (a > 0);
            text = Math.abs(a).toString();
        }
        if (this.el) {
            this.getCheckbox().checked = checked;
            this.getTextInput().value = text;
        }
    },
    validate: function() {
        return true;
    },
    getName: function() {
        return this.name;
    }
});

Ext.reg("chktxtcombo", kw.widget.datatable.config.CheckTextCombo);
})();

/* InitialDate.js */

Ext.namespace("kw.widget.datatable.config");

kw.widget.datatable.config.InitialDate = function(config) {

    kw.widget.datatable.config.InitialDate.superclass.constructor.call(this, config);

    if (typeof kw.widget.datatable.config.InitialDate.nlsBag == "undefined") {
        kw.widget.datatable.config.InitialDate.nlsBag = {};
        kw.RcmpBinding.getNlsStrings("cma.kw.form.DateField", [
            "blankDate",
            "createDate",
            "createDatePlus",
            "days",
            "initialDateHelpText",
            "initialDatePlusDaysBlankText"
        ], kw.widget.datatable.config.InitialDate.nlsBag);
    }

    if (!config.value) {
        this.reset();
    }
}

kw.widget.datatable.config.InitialDate.getDefaultValue = function(jsonValue) {
    var v = Ext.util.JSON.decode(jsonValue)

    if (v[0] == 1)
        return null;

    var now = new Date();
    if (v[0] == 2)
        return now;

    var plusDays = parseInt(v[1]);
    return now.add(Date.DAY, plusDays);
};

Ext.extend(kw.widget.datatable.config.InitialDate, Ext.form.Field,{

    onRender: function(ct, pos) {
        if (this.el)
            return;

        this.el = Ext.get(document.createElement('div'));
        this.el.id = this.id;
        this.el.dom.id = this.id;
        this.el.addClass("kw-initdate");

        var nlsBag = kw.widget.datatable.config.InitialDate.nlsBag;
        var markup = [
                "<div class=\"kw-initdate-option\"><input class=\"kw-initdate-input\" type=\"radio\" value=\"1\" name=\"initdate\"/>",
                "<span>" + nlsBag.blankDate + "</span>",
                "</div>",
                "<div class=\"kw-initdate-option\"><input class=\"kw-initdate-input\" type=\"radio\" value=\"2\" name=\"initdate\"/>",
                "<span>" + nlsBag.createDate + "</span>",
                "</div>",
                "<div class=\"kw-initdate-option\"><input class=\"kw-initdate-input\" type=\"radio\" value=\"3\" name=\"initdate\"/>",
                "<div class=\"kw-initdate-plus\"><span>" + nlsBag.createDatePlus +  "</span>",
                "<span class=\"kw-initdate-plusdays\"></span>",
                "<span>" + nlsBag.days + "</span></div>",
                "</div>"
                ].join("");

        this.el.update(markup);


        this.radios = Ext.query("input[type='radio']", this.el.dom);

        kw.widget.datatable.config.InitialDate.superclass.onRender.apply(this, arguments);

        var plusDaysNode = Ext.DomQuery.selectNode(".kw-initdate-plusdays", this.el.dom);
        this.plusDays = new Ext.form.NumberField({minValue: -365, maxValue: 365,
            autoCreate: {tag: 'input', type: 'text', style: {width: '20px !important'},
                cls: "kw-initdate-plusdays-input kw-text-general"},
                autocomplete: 'off', maxlength: '6', enableKeyEvents: true,
                renderTo: plusDaysNode, allowBlank: false,
                blankText: kw.widget.datatable.config.InitialDate.nlsBag.initialDatePlusDaysBlankText,
                msgTarget: "under",
                plugins: new kw.widget.FieldPlugIn({
                    helpText: kw.widget.datatable.config.InitialDate.nlsBag.initialDateHelpText})
        });
        this.plusDays.on("keypress", this.onPlusDaysKeyPress.createDelegate(this));
        
        this.plusDays.getErrorCt = function(){
            return this.el.findParent('.x-form-element', 15, true) || // use form element wrap if available
            this.el.findParent('.x-form-field-wrap', 15, true); // else direct field wrap
        }

    },


    onPlusDaysKeyPress: function(e) {
        this.radios[2].checked = true;
    },

    getValue: function() {
        if (!this.el)
            return this.value;

        var v = [0,0];
        for (var i=0; i < this.radios.length; ++i) {
            if (this.radios[i].checked) {
                v[0] = this.radios[i].value;
                break;
            }
        }
        if (v[0] == 3) {
            var plusdays = this.plusDays.getValue();
            if (plusdays)
                v[1] = plusdays;
        }

        return Ext.util.JSON.encode(v);
    },
    isDirty: function() {
        return true;
    },
    isValid: function() {
        return this.validate();
    },
    reset: function() {
        this.value = "[1,0]";
    },
    setValue: function(a) {
        this.setRawValue(a);
    },
    setRawValue: function(a) {
        this.value = Ext.util.JSON.decode(a);
        var v = this.value;
        if (v.length == 2) {
            for (var i=0; i < this.radios.length; ++i) {
                if (this.radios[i].value == v[0]) {
                    this.radios[i].checked = true;
                    break;
                }
            }
            if (v[1] != 0) {
                this.plusDays.setValue(v[1]);
            }
        }
    },
    validate: function() {
        if (this.radios[2].checked) {
            return this.plusDays.validate();
        } else {
            this.plusDays.clearInvalid();
        }
        return true;
    },
    getName: function() {
        return this.name;
    }
});

Ext.reg("initialdate", kw.widget.datatable.config.InitialDate);

/* LifecycleCombo.js */

Ext.namespace("kw.widget.datatable.config");

(function() {
    kw.widget.datatable.config.LifecycleCombo = function(config) {
        Ext.applyIf(config, {
            name : 'lifecycles',
            triggerAction : 'all',
            editable : false,
            store : [['','']],
            mode : 'local',
            disabled : true
        });
        
        this.constructor.superclass.constructor.call(this, config);

        this.on("afterrender", this.lcLoadCombo, this);
        this.on("select", this.lcOnSelect, this);
    }

    Ext.extend(kw.widget.datatable.config.LifecycleCombo, Ext.form.ComboBox, {
        lcMap : [],
        lcResponseToMap : function(data) { // takes response from fetch and maps into map
            var items = [];
            for (var i = 0; i < data.rows.length; i++) {
                var lifecycle = {
                    id : data.rows[i].cells[0].value.id,
                    name : data.rows[i].cells[1].value,
                    states : []
                }
                var count = 0;
                for(var j = data.rows[i].cells[2].value.length-1; j > 0; j--) {
                    var state =  {
                        id : count,
                        name : data.rows[i].cells[2].value[j],
                        enabled : data.rows[i].cells[3].value[j]
                    }
                    lifecycle.states.push(state);
                    count++;
                }
                items.push(lifecycle);
            }
            this.lcMap = items;
        },
        lcToArray : function() {
            var lifecycles = [];
            for(var i=0; i < this.lcMap.length; i++) {
                var lifecycle = [this.lcMap[i].id,this.lcMap[i].name];
                lifecycles.push(lifecycle);
            }
            return lifecycles;
        },
        lcGetLc : function(lifecycleId) {
          for(var i=0; i< this.lcMap.length; i++) {
              if(this.lcMap[i].id == lifecycleId) {
                return(this.lcMap[i]);     
              }
          }
        },
        lcStatesToArray : function (lifecycleId) {
            var states = [];
            var lifecycle = this.lcGetLc(lifecycleId);
            for(var i=0; i < lifecycle.states.length; i++) {
                if(lifecycle.states[i].enabled == 1) { // check to see if state is active
                    var state = [lifecycle.states[i].id,lifecycle.states[i].name];
                    states.push(state);
                }
            }
            return states;
        },

        lcLoadCombo: function () {
            var _onComplete = function(data){
                this.lcResponseToMap(data);
                
                // No lifecycles in this docbase
                if(this.lcMap.length == 0) {
                   var body = kw.buildDialogBody(kw.Strings.Error.errorOccured, Ext.util.Format.htmlEncode(kw.Strings.Datatable.Lifecycle.noLifecycles));
                   var el = this.el;
                   kw.MessageBox.show({
                       msg:     body,
                       buttons: {ok: kw.Strings.btnClose},
                       icon:    Ext.MessageBox.ERROR,
                       cls:     'kw-msg-alert',
                       fn: function() {
                            Ext.getCmp(Ext.get(el).findParentNode('.kwdialog').id).cancel();
                       }
                   }, null);
                }

                var lifecycles = this.lcToArray();
                
                this.store.loadData(lifecycles);
                if(this.getValue().length != 0) {
                    this.setValue(this.getValue());
                } else {
                    this.setValue(this.lcMap[0].id);    
                }
                this.lcOnSelect();

                this.enable();
            };
            var _onError = function(){};
            var callbackProxy = kw.getCallbackClosure(this, _onComplete, _onError);

            var query = {
                datalistId: 'datatable_row_lifecycles',
                repositories: [this.actionArgs.context.repository]
            };
            ListService.fetchResults(query, null, null, callbackProxy);
        },
        lcStateExists : function(states, value) {
          for(var i=0; i<states.length; i++) {
              if(states[i][0] == value) {
                  return true;
              }
          }
          return false;
        },
        lcOnSelect : function() {
            var initialComboId = this.ownerCt.getForm().findField('_defaultValue').id;
            var initialCombo = Ext.getCmp(initialComboId);

            var lifecycleId = this.getValue();

            var states = this.lcStatesToArray(lifecycleId);
            
            initialCombo.store.loadData(states);

            if(initialCombo.getValue() != 0) {
                var value = initialCombo.getValue();
                if(this.lcStateExists(states,value)) {
                    initialCombo.setValue(initialCombo.getValue());
                } else {
                    initialCombo.setValue(states[0][0]);
                }
            } else {
                initialCombo.setValue(states[0][0]);
            }
            
            initialCombo.enable();
            
        },
        setValue : function(v) {
            kw.widget.datatable.config.LifecycleCombo.superclass.setValue.call(this, v);
        }
    });
    
	Ext.reg("lifecyclecombo", kw.widget.datatable.config.LifecycleCombo);
})();
/* RequiredCheckbox.js */

Ext.namespace("kw.widget.datatable.config");
// This is a specialized control used in config dialogs of the datatable field widgets.
// It implements the functionality of making sure that a field is required if it is
// currently the "entry name" field of the datatable being configured.

(function() {

    kw.widget.datatable.config.RequiredCheckbox = function(config) {
        config.boxLabel = config.fieldLabel;
        config.fieldLabel = "";
        config.labelSeparator = "";
        config.checked = config.value;

        this.constructor.superclass.constructor.call(this, config);
    }

    Ext.extend(kw.widget.datatable.config.RequiredCheckbox, Ext.form.Checkbox, {
        onRender: function() {
            this.constructor.superclass.onRender.apply(this, arguments);
            var dlg = this.findParentBy(function(c) {return c instanceof kw.Dialog.WidgetConfig;});
            if (dlg) {
                var portlet = dlg.actionArgs.component;
                if (portlet) {
                    var f = portlet.findBy(function(c){return c.isKwDatatableField;});
                    if (f.length && f[0].isTitleField) {
                        this.setValue(true);
                        this.disable();
                    }
                }
            }
        }
    });

    Ext.reg("dtreqchkbox", kw.widget.datatable.config.RequiredCheckbox);    
})()